diff options
Diffstat (limited to 'tests')
-rw-r--r-- | tests/vb20_api_kernel_tests.c | 156 | ||||
-rw-r--r-- | tests/vb20_api_tests.c | 122 | ||||
-rw-r--r-- | tests/vb20_kernel_tests.c | 122 | ||||
-rw-r--r-- | tests/vb20_misc_tests.c | 106 | ||||
-rw-r--r-- | tests/vb20_verify_fw.c | 22 | ||||
-rw-r--r-- | tests/vb2_api_tests.c | 202 | ||||
-rw-r--r-- | tests/vb2_misc_tests.c | 330 | ||||
-rw-r--r-- | tests/vb2_nvstorage_tests.c | 6 | ||||
-rw-r--r-- | tests/vb2_secdata_tests.c | 8 | ||||
-rw-r--r-- | tests/vb2_secdatak_tests.c | 8 |
10 files changed, 541 insertions, 541 deletions
diff --git a/tests/vb20_api_kernel_tests.c b/tests/vb20_api_kernel_tests.c index 3a2de215..0d48c75c 100644 --- a/tests/vb20_api_kernel_tests.c +++ b/tests/vb20_api_kernel_tests.c @@ -20,7 +20,7 @@ /* Common context for tests */ static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE] __attribute__ ((aligned (VB2_WORKBUF_ALIGN))); -static struct vb2_context cc; +static struct vb2_context ctx; static struct vb2_shared_data *sd; static struct vb2_fw_preamble *fwpre; static struct vb2_kernel_preamble *kpre; @@ -55,18 +55,18 @@ static void reset_common_data(enum reset_type t) memset(workbuf, 0xaa, sizeof(workbuf)); - memset(&cc, 0, sizeof(cc)); - cc.workbuf = workbuf; - cc.workbuf_size = sizeof(workbuf); + memset(&ctx, 0, sizeof(ctx)); + ctx.workbuf = workbuf; + ctx.workbuf_size = sizeof(workbuf); - vb2_init_context(&cc); - sd = vb2_get_sd(&cc); + vb2_init_context(&ctx); + sd = vb2_get_sd(&ctx); - vb2_nv_init(&cc); + vb2_nv_init(&ctx); - vb2_secdatak_create(&cc); - vb2_secdatak_init(&cc); - vb2_secdatak_set(&cc, VB2_SECDATAK_VERSIONS, 0x20002); + vb2_secdatak_create(&ctx); + vb2_secdatak_init(&ctx); + vb2_secdatak_set(&ctx, VB2_SECDATAK_VERSIONS, 0x20002); mock_read_res_fail_on_call = 0; mock_unpack_key_retval = VB2_SUCCESS; @@ -92,9 +92,9 @@ static void reset_common_data(enum reset_type t) uint8_t *kdata; /* Create mock firmware preamble in the context */ - sd->workbuf_preamble_offset = cc.workbuf_used; + sd->workbuf_preamble_offset = ctx.workbuf_used; fwpre = (struct vb2_fw_preamble *) - (cc.workbuf + sd->workbuf_preamble_offset); + (ctx.workbuf + sd->workbuf_preamble_offset); k = &fwpre->kernel_subkey; kdata = (uint8_t *)fwpre + sizeof(*fwpre); memcpy(kdata, fw_kernel_key_data, sizeof(fw_kernel_key_data)); @@ -102,7 +102,7 @@ static void reset_common_data(enum reset_type t) k->key_offset = vb2_offset_of(k, kdata); k->key_size = sizeof(fw_kernel_key_data); sd->workbuf_preamble_size = sizeof(*fwpre) + k->key_size; - vb2_set_workbuf_used(&cc, sd->workbuf_preamble_offset + + vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset + sd->workbuf_preamble_size); } else if (t == FOR_PHASE2) { @@ -111,18 +111,18 @@ static void reset_common_data(enum reset_type t) uint8_t *sdata; /* Create mock kernel data key */ - sd->workbuf_data_key_offset = cc.workbuf_used; + sd->workbuf_data_key_offset = ctx.workbuf_used; kdkey = (struct vb2_packed_key *) - (cc.workbuf + sd->workbuf_data_key_offset); + (ctx.workbuf + sd->workbuf_data_key_offset); kdkey->algorithm = VB2_ALG_RSA2048_SHA256; sd->workbuf_data_key_size = sizeof(*kdkey); - vb2_set_workbuf_used(&cc, sd->workbuf_data_key_offset + + vb2_set_workbuf_used(&ctx, sd->workbuf_data_key_offset + sd->workbuf_data_key_size); /* Create mock kernel preamble in the context */ - sd->workbuf_preamble_offset = cc.workbuf_used; + sd->workbuf_preamble_offset = ctx.workbuf_used; kpre = (struct vb2_kernel_preamble *) - (cc.workbuf + sd->workbuf_preamble_offset); + (ctx.workbuf + sd->workbuf_preamble_offset); sdata = (uint8_t *)kpre + sizeof(*kpre); sig = &kpre->body_signature; @@ -138,7 +138,7 @@ static void reset_common_data(enum reset_type t) sd->workbuf_preamble_size = sizeof(*kpre) + sig->sig_size; sd->vblock_preamble_offset = 0x10000 - sd->workbuf_preamble_size; - vb2_set_workbuf_used(&cc, sd->workbuf_preamble_offset + + vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset + sd->workbuf_preamble_size); } else { @@ -146,13 +146,13 @@ static void reset_common_data(enum reset_type t) sd->kernel_version = 0x20004; sd->kernel_version_secdatak = 0x20002; sd->flags |= VB2_SD_FLAG_KERNEL_SIGNED; - cc.flags |= VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD; + ctx.flags |= VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD; } }; /* Mocked functions */ -int vb2ex_read_resource(struct vb2_context *ctx, +int vb2ex_read_resource(struct vb2_context *c, enum vb2_resource_index index, uint32_t offset, void *buf, @@ -180,18 +180,18 @@ int vb2ex_read_resource(struct vb2_context *ctx, return VB2_SUCCESS; } -int vb2_read_gbb_header(struct vb2_context *ctx, struct vb2_gbb_header *gbb) +int vb2_read_gbb_header(struct vb2_context *c, struct vb2_gbb_header *gbb) { memcpy(gbb, &mock_gbb.h, sizeof(*gbb)); return mock_read_gbb_header_retval; } -int vb2_load_kernel_keyblock(struct vb2_context *ctx) +int vb2_load_kernel_keyblock(struct vb2_context *c) { return mock_load_kernel_keyblock_retval; } -int vb2_load_kernel_preamble(struct vb2_context *ctx) +int vb2_load_kernel_preamble(struct vb2_context *c) { return mock_load_kernel_preamble_retval; } @@ -228,16 +228,16 @@ static void phase1_tests(void) /* Test successful call */ reset_common_data(FOR_PHASE1); old_preamble_offset = sd->workbuf_preamble_offset; - TEST_SUCC(vb2api_kernel_phase1(&cc), "phase1 good"); + TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 good"); TEST_EQ(sd->workbuf_preamble_size, 0, " no more fw preamble"); /* Make sure normal key was loaded */ TEST_EQ(sd->workbuf_kernel_key_offset, old_preamble_offset, " workbuf key offset"); k = (struct vb2_packed_key *) - (cc.workbuf + sd->workbuf_kernel_key_offset); + (ctx.workbuf + sd->workbuf_kernel_key_offset); TEST_EQ(sd->workbuf_kernel_key_size, k->key_offset + k->key_size, " workbuf key size"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_kernel_key_offset + sd->workbuf_kernel_key_size), " workbuf used"); @@ -249,20 +249,20 @@ static void phase1_tests(void) /* Test successful call in recovery mode */ reset_common_data(FOR_PHASE1); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; /* No preamble loaded in recovery mode */ - cc.workbuf_used = old_preamble_offset = sd->workbuf_preamble_offset; + ctx.workbuf_used = old_preamble_offset = sd->workbuf_preamble_offset; sd->workbuf_preamble_offset = sd->workbuf_preamble_size = 0; - TEST_SUCC(vb2api_kernel_phase1(&cc), "phase1 rec good"); + TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 rec good"); TEST_EQ(sd->workbuf_preamble_size, 0, "no more fw preamble"); /* Make sure recovery key was loaded */ TEST_EQ(sd->workbuf_kernel_key_offset, old_preamble_offset, " workbuf key offset"); k = (struct vb2_packed_key *) - (cc.workbuf + sd->workbuf_kernel_key_offset); + (ctx.workbuf + sd->workbuf_kernel_key_offset); TEST_EQ(sd->workbuf_kernel_key_size, k->key_offset + k->key_size, " workbuf key size"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_kernel_key_offset + sd->workbuf_kernel_key_size), " workbuf used"); @@ -275,63 +275,63 @@ static void phase1_tests(void) /* Bad secdatak causes failure in normal mode only */ reset_common_data(FOR_PHASE1); - cc.secdatak[0] ^= 0x33; - TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_SECDATAK_CRC, + ctx.secdatak[0] ^= 0x33; + TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_SECDATAK_CRC, "phase1 bad secdata"); reset_common_data(FOR_PHASE1); - cc.secdatak[0] ^= 0x33; - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; - TEST_SUCC(vb2api_kernel_phase1(&cc), "phase1 bad secdata rec"); + ctx.secdatak[0] ^= 0x33; + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; + TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 bad secdata rec"); TEST_EQ(sd->kernel_version_secdatak, 0, " secdatak version"); /* Failures while reading recovery key */ reset_common_data(FOR_PHASE1); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sizeof(struct vb2_gbb_header)); - TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_GBB_WORKBUF, + TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_GBB_WORKBUF, "phase1 rec workbuf gbb header"); reset_common_data(FOR_PHASE1); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; mock_read_gbb_header_retval = VB2_ERROR_MOCK; - TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_MOCK, + TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_MOCK, "phase1 rec gbb read header"); reset_common_data(FOR_PHASE1); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; - mock_gbb.h.recovery_key_size = cc.workbuf_size - 1; - TEST_EQ(vb2api_kernel_phase1(&cc), + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; + mock_gbb.h.recovery_key_size = ctx.workbuf_size - 1; + TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_API_KPHASE1_WORKBUF_REC_KEY, "phase1 rec workbuf key"); reset_common_data(FOR_PHASE1); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; mock_read_res_fail_on_call = 1; - TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_MOCK, + TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_MOCK, "phase1 rec gbb read key"); /* Failures while parsing subkey from firmware preamble */ reset_common_data(FOR_PHASE1); sd->workbuf_preamble_size = 0; - TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_API_KPHASE1_PREAMBLE, + TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_API_KPHASE1_PREAMBLE, "phase1 fw preamble"); } static void load_kernel_vblock_tests(void) { reset_common_data(FOR_PHASE1); - TEST_SUCC(vb2api_load_kernel_vblock(&cc), "load vblock good"); + TEST_SUCC(vb2api_load_kernel_vblock(&ctx), "load vblock good"); reset_common_data(FOR_PHASE1); mock_load_kernel_keyblock_retval = VB2_ERROR_MOCK; - TEST_EQ(vb2api_load_kernel_vblock(&cc), VB2_ERROR_MOCK, + TEST_EQ(vb2api_load_kernel_vblock(&ctx), VB2_ERROR_MOCK, "load vblock bad keyblock"); reset_common_data(FOR_PHASE1); mock_load_kernel_preamble_retval = VB2_ERROR_MOCK; - TEST_EQ(vb2api_load_kernel_vblock(&cc), VB2_ERROR_MOCK, + TEST_EQ(vb2api_load_kernel_vblock(&ctx), VB2_ERROR_MOCK, "load vblock bad preamble"); } @@ -341,17 +341,17 @@ static void get_kernel_size_tests(void) reset_common_data(FOR_PHASE2); offs = size = 0; - TEST_SUCC(vb2api_get_kernel_size(&cc, &offs, &size), "get size good"); + TEST_SUCC(vb2api_get_kernel_size(&ctx, &offs, &size), "get size good"); TEST_EQ(offs, 0x10000, " offset"); TEST_EQ(size, sizeof(kernel_data), " size"); /* Don't need to pass pointers */ reset_common_data(FOR_PHASE2); - TEST_SUCC(vb2api_get_kernel_size(&cc, NULL, NULL), "get size null"); + TEST_SUCC(vb2api_get_kernel_size(&ctx, NULL, NULL), "get size null"); reset_common_data(FOR_PHASE2); sd->workbuf_preamble_size = 0; - TEST_EQ(vb2api_get_kernel_size(&cc, &offs, &size), + TEST_EQ(vb2api_get_kernel_size(&ctx, &offs, &size), VB2_ERROR_API_GET_KERNEL_SIZE_PREAMBLE, "get size no preamble"); } @@ -359,56 +359,56 @@ static void get_kernel_size_tests(void) static void verify_kernel_data_tests(void) { reset_common_data(FOR_PHASE2); - TEST_SUCC(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_SUCC(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), "verify data good"); reset_common_data(FOR_PHASE2); sd->workbuf_preamble_size = 0; - TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_API_VERIFY_KDATA_PREAMBLE, "verify no preamble"); reset_common_data(FOR_PHASE2); - TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data) + 1), VB2_ERROR_API_VERIFY_KDATA_SIZE, "verify size"); reset_common_data(FOR_PHASE2); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sizeof(struct vb2_digest_context)); - TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_API_VERIFY_KDATA_WORKBUF, "verify workbuf"); reset_common_data(FOR_PHASE2); sd->workbuf_data_key_size = 0; - TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_API_VERIFY_KDATA_KEY, "verify no key"); reset_common_data(FOR_PHASE2); mock_unpack_key_retval = VB2_ERROR_MOCK; - TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_MOCK, "verify unpack key"); reset_common_data(FOR_PHASE2); kdkey->algorithm = VB2_ALG_COUNT; - TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_SHA_INIT_ALGORITHM, "verify hash init"); reset_common_data(FOR_PHASE2); - cc.workbuf_used = cc.workbuf_size - + ctx.workbuf_used = ctx.workbuf_size - vb2_wb_round_up(sizeof(struct vb2_digest_context)); - TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_API_CHECK_HASH_WORKBUF_DIGEST, "verify hash workbuf"); reset_common_data(FOR_PHASE2); kernel_data[3] ^= 0xd0; - TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data, + TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data, sizeof(kernel_data)), VB2_ERROR_VDATA_VERIFY_DIGEST, "verify hash digest"); kernel_data[3] ^= 0xd0; @@ -419,37 +419,37 @@ static void phase3_tests(void) uint32_t v; reset_common_data(FOR_PHASE3); - TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 good"); - vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v); + TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 good"); + vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v); TEST_EQ(v, 0x20004, " version"); reset_common_data(FOR_PHASE3); sd->kernel_version = 0x20001; - TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 no rollback"); - vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v); + TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 no rollback"); + vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v); TEST_EQ(v, 0x20002, " version"); reset_common_data(FOR_PHASE3); sd->flags &= ~VB2_SD_FLAG_KERNEL_SIGNED; - TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 unsigned kernel"); - vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v); + TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 unsigned kernel"); + vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v); TEST_EQ(v, 0x20002, " version"); reset_common_data(FOR_PHASE3); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; - TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 recovery"); - vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v); + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; + TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 recovery"); + vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v); TEST_EQ(v, 0x20002, " version"); reset_common_data(FOR_PHASE3); - cc.flags &= ~VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD; - TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 no rollforward"); - vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v); + ctx.flags &= ~VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD; + TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 no rollforward"); + vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v); TEST_EQ(v, 0x20002, " version"); reset_common_data(FOR_PHASE3); sd->status &= ~VB2_SD_STATUS_SECDATAK_INIT; - TEST_EQ(vb2api_kernel_phase3(&cc), + TEST_EQ(vb2api_kernel_phase3(&ctx), VB2_ERROR_SECDATAK_SET_UNINITIALIZED, "phase3 set fail"); } diff --git a/tests/vb20_api_tests.c b/tests/vb20_api_tests.c index 3a5d4968..6c43391e 100644 --- a/tests/vb20_api_tests.c +++ b/tests/vb20_api_tests.c @@ -19,7 +19,7 @@ /* Common context for tests */ static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE] __attribute__ ((aligned (VB2_WORKBUF_ALIGN))); -static struct vb2_context cc; +static struct vb2_context ctx; static struct vb2_shared_data *sd; const char mock_body[320] = "Mock body"; @@ -57,29 +57,29 @@ static void reset_common_data(enum reset_type t) memset(workbuf, 0xaa, sizeof(workbuf)); - memset(&cc, 0, sizeof(cc)); - cc.workbuf = workbuf; - cc.workbuf_size = sizeof(workbuf); + memset(&ctx, 0, sizeof(ctx)); + ctx.workbuf = workbuf; + ctx.workbuf_size = sizeof(workbuf); - vb2_init_context(&cc); - sd = vb2_get_sd(&cc); + vb2_init_context(&ctx); + sd = vb2_get_sd(&ctx); - vb2_nv_init(&cc); + vb2_nv_init(&ctx); - vb2_secdata_create(&cc); - vb2_secdata_init(&cc); + vb2_secdata_create(&ctx); + vb2_secdata_init(&ctx); 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; - sd->workbuf_preamble_offset = cc.workbuf_used; + sd->workbuf_preamble_offset = ctx.workbuf_used; sd->workbuf_preamble_size = sizeof(*pre); - vb2_set_workbuf_used(&cc, sd->workbuf_preamble_offset + vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset + sd->workbuf_preamble_size); pre = (struct vb2_fw_preamble *) - (cc.workbuf + sd->workbuf_preamble_offset); + (ctx.workbuf + sd->workbuf_preamble_offset); pre->body_signature.data_size = mock_body_size; pre->body_signature.sig_size = mock_sig_size; if (hwcrypto_state == HWCRYPTO_FORBIDDEN) @@ -87,19 +87,19 @@ static void reset_common_data(enum reset_type t) else pre->flags = 0; - sd->workbuf_data_key_offset = cc.workbuf_used; + sd->workbuf_data_key_offset = ctx.workbuf_used; sd->workbuf_data_key_size = sizeof(*k) + 8; - vb2_set_workbuf_used(&cc, sd->workbuf_data_key_offset + + vb2_set_workbuf_used(&ctx, sd->workbuf_data_key_offset + sd->workbuf_data_key_size); k = (struct vb2_packed_key *) - (cc.workbuf + sd->workbuf_data_key_offset); + (ctx.workbuf + sd->workbuf_data_key_offset); k->algorithm = mock_algorithm; if (t == FOR_EXTEND_HASH || t == FOR_CHECK_HASH) - vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, NULL); + vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, NULL); if (t == FOR_CHECK_HASH) - vb2api_extend_hash(&cc, mock_body, mock_body_size); + vb2api_extend_hash(&ctx, mock_body, mock_body_size); /* Always clear out the digest result. */ memset(digest_result, 0, digest_result_size); @@ -107,12 +107,12 @@ static void reset_common_data(enum reset_type t) /* Mocked functions */ -int vb2_load_fw_keyblock(struct vb2_context *ctx) +int vb2_load_fw_keyblock(struct vb2_context *c) { return retval_vb2_load_fw_keyblock; } -int vb2_load_fw_preamble(struct vb2_context *ctx) +int vb2_load_fw_preamble(struct vb2_context *c) { return retval_vb2_load_fw_preamble; } @@ -233,18 +233,18 @@ int vb2_rsa_verify_digest(const struct vb2_public_key *key, static void phase3_tests(void) { reset_common_data(FOR_MISC); - TEST_SUCC(vb2api_fw_phase3(&cc), "phase3 good"); + 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(&cc), VB2_ERROR_MOCK, "phase3 keyblock"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + 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(&cc), VB2_ERROR_MOCK, "phase3 keyblock"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + 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"); } @@ -256,58 +256,58 @@ static void init_hash_tests(void) /* For now, all we support is body signature hash */ reset_common_data(FOR_MISC); - wb_used_before = cc.workbuf_used; - TEST_SUCC(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size), + wb_used_before = ctx.workbuf_used; + TEST_SUCC(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), "init hash good"); TEST_EQ(sd->workbuf_hash_offset, wb_used_before, "hash context offset"); TEST_EQ(sd->workbuf_hash_size, sizeof(struct vb2_digest_context), "hash context size"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_hash_offset + sd->workbuf_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 = cc.workbuf_used; - TEST_SUCC(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, NULL), + wb_used_before = ctx.workbuf_used; + TEST_SUCC(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, NULL), "init hash again"); - TEST_EQ(cc.workbuf_used, wb_used_before, "init hash reuses context"); + TEST_EQ(ctx.workbuf_used, wb_used_before, "init hash reuses context"); reset_common_data(FOR_MISC); - TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_INVALID, &size), + TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_INVALID, &size), VB2_ERROR_API_INIT_HASH_TAG, "init hash invalid tag"); reset_common_data(FOR_MISC); sd->workbuf_preamble_size = 0; - TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size), + TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_API_INIT_HASH_PREAMBLE, "init hash preamble"); reset_common_data(FOR_MISC); - TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY + 1, &size), + TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY + 1, &size), VB2_ERROR_API_INIT_HASH_TAG, "init hash unknown tag"); reset_common_data(FOR_MISC); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sizeof(struct vb2_digest_context)); - TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size), + TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_API_INIT_HASH_WORKBUF, "init hash workbuf"); reset_common_data(FOR_MISC); sd->workbuf_data_key_size = 0; - TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size), + TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_API_INIT_HASH_DATA_KEY, "init hash data key"); reset_common_data(FOR_MISC); sd->workbuf_data_key_size--; - TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size), + TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_UNPACK_KEY_SIZE, "init hash data key size"); reset_common_data(FOR_MISC); - k = (struct vb2_packed_key *)(cc.workbuf + sd->workbuf_data_key_offset); + k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset); k->algorithm--; - TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size), + TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size), VB2_ERROR_SHA_INIT_ALGORITHM, "init hash algorithm"); } @@ -316,33 +316,33 @@ static void extend_hash_tests(void) struct vb2_digest_context *dc; reset_common_data(FOR_EXTEND_HASH); - TEST_SUCC(vb2api_extend_hash(&cc, mock_body, 32), + 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(&cc, mock_body, mock_body_size - 32), + 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->workbuf_hash_size = 0; - TEST_EQ(vb2api_extend_hash(&cc, mock_body, mock_body_size), + 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(&cc, mock_body, mock_body_size + 1), + 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(&cc, mock_body, 0), + TEST_EQ(vb2api_extend_hash(&ctx, mock_body, 0), VB2_ERROR_API_EXTEND_HASH_SIZE, "hash extend empty"); if (hwcrypto_state != HWCRYPTO_ENABLED) { reset_common_data(FOR_EXTEND_HASH); dc = (struct vb2_digest_context *) - (cc.workbuf + sd->workbuf_hash_offset); + (ctx.workbuf + sd->workbuf_hash_offset); dc->hash_alg = mock_hash_alg + 1; - TEST_EQ(vb2api_extend_hash(&cc, mock_body, mock_body_size), + TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size), VB2_ERROR_SHA_EXTEND_ALGORITHM, "hash extend fail"); } } @@ -353,17 +353,17 @@ static void check_hash_tests(void) const uint32_t digest_value = 0x0a0a0a0a; reset_common_data(FOR_CHECK_HASH); - TEST_SUCC(vb2api_check_hash(&cc), "check hash good"); + TEST_SUCC(vb2api_check_hash(&ctx), "check hash good"); reset_common_data(FOR_CHECK_HASH); - TEST_SUCC(vb2api_check_hash_get_digest(&cc, digest_result, + 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"); reset_common_data(FOR_CHECK_HASH); - TEST_EQ(vb2api_check_hash_get_digest(&cc, digest_result, + 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, @@ -371,53 +371,53 @@ static void check_hash_tests(void) reset_common_data(FOR_CHECK_HASH); sd->workbuf_preamble_size = 0; - TEST_EQ(vb2api_check_hash(&cc), + TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_API_CHECK_HASH_PREAMBLE, "check hash preamble"); reset_common_data(FOR_CHECK_HASH); sd->workbuf_hash_size = 0; - TEST_EQ(vb2api_check_hash(&cc), + 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(&cc), + TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_API_CHECK_HASH_SIZE, "check hash size"); reset_common_data(FOR_CHECK_HASH); - cc.workbuf_used = cc.workbuf_size; - TEST_EQ(vb2api_check_hash(&cc), + ctx.workbuf_used = ctx.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(&cc), VB2_ERROR_MOCK, "check hash finalize"); + 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(&cc), + TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag"); reset_common_data(FOR_CHECK_HASH); sd->workbuf_data_key_size = 0; - TEST_EQ(vb2api_check_hash(&cc), + TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_API_CHECK_HASH_DATA_KEY, "check hash data key"); reset_common_data(FOR_CHECK_HASH); sd->workbuf_data_key_size--; - TEST_EQ(vb2api_check_hash(&cc), + TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_UNPACK_KEY_SIZE, "check hash data key size"); reset_common_data(FOR_CHECK_HASH); pre = (struct vb2_fw_preamble *) - (cc.workbuf + sd->workbuf_preamble_offset); + (ctx.workbuf + sd->workbuf_preamble_offset); pre->body_signature.sig_size++; - TEST_EQ(vb2api_check_hash(&cc), + 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(&cc), + TEST_EQ(vb2api_check_hash(&ctx), VB2_ERROR_RSA_VERIFY_DIGEST, "check hash finalize"); } diff --git a/tests/vb20_kernel_tests.c b/tests/vb20_kernel_tests.c index 6d936285..ec70f4bb 100644 --- a/tests/vb20_kernel_tests.c +++ b/tests/vb20_kernel_tests.c @@ -21,7 +21,7 @@ static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE] __attribute__ ((aligned (VB2_WORKBUF_ALIGN))); static struct vb2_workbuf wb; -static struct vb2_context cc; +static struct vb2_context ctx; static struct vb2_shared_data *sd; /* Mocked function data */ @@ -80,18 +80,18 @@ static void reset_common_data(enum reset_type t) memset(workbuf, 0xaa, sizeof(workbuf)); - memset(&cc, 0, sizeof(cc)); - cc.workbuf = workbuf; - cc.workbuf_size = sizeof(workbuf); - vb2_workbuf_from_ctx(&cc, &wb); + memset(&ctx, 0, sizeof(ctx)); + ctx.workbuf = workbuf; + ctx.workbuf_size = sizeof(workbuf); + vb2_workbuf_from_ctx(&ctx, &wb); - vb2_init_context(&cc); - sd = vb2_get_sd(&cc); + vb2_init_context(&ctx); + sd = vb2_get_sd(&ctx); - vb2_nv_init(&cc); + vb2_nv_init(&ctx); - vb2_secdatak_create(&cc); - vb2_secdatak_init(&cc); + vb2_secdatak_create(&ctx); + vb2_secdatak_init(&ctx); mock_read_res_fail_on_call = 0; mock_unpack_key_retval = VB2_SUCCESS; @@ -100,7 +100,7 @@ static void reset_common_data(enum reset_type t) /* Set up mock data for verifying keyblock */ sd->kernel_version_secdatak = 0x20002; - vb2_secdatak_set(&cc, VB2_SECDATAK_VERSIONS, 0x20002); + vb2_secdatak_set(&ctx, VB2_SECDATAK_VERSIONS, 0x20002); mock_gbb.recovery_key.algorithm = 11; mock_gbb.recovery_key.key_offset = @@ -130,12 +130,12 @@ static void reset_common_data(enum reset_type t) /* If verifying preamble, verify keyblock first to set up data key */ if (t == FOR_PREAMBLE) - vb2_load_kernel_keyblock(&cc); + vb2_load_kernel_keyblock(&ctx); }; /* Mocked functions */ -int vb2ex_read_resource(struct vb2_context *ctx, +int vb2ex_read_resource(struct vb2_context *c, enum vb2_resource_index index, uint32_t offset, void *buf, @@ -246,30 +246,30 @@ static void load_kernel_keyblock_tests(void) /* Test successful call */ reset_common_data(FOR_KEYBLOCK); - wb_used_before = cc.workbuf_used; - TEST_SUCC(vb2_load_kernel_keyblock(&cc), "Kernel keyblock good"); + wb_used_before = ctx.workbuf_used; + TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock good"); TEST_NEQ(sd->flags & VB2_SD_FLAG_KERNEL_SIGNED, 0, " Kernel signed"); TEST_EQ(sd->kernel_version, 0x20000, "keyblock version"); TEST_EQ(sd->vblock_preamble_offset, sizeof(mock_vblock.k), "preamble offset"); TEST_EQ(sd->workbuf_data_key_offset, wb_used_before, "keyblock data key offset"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_data_key_offset + sd->workbuf_data_key_size), "workbuf used"); /* Make sure data key was properly saved */ - k = (struct vb2_packed_key *)(cc.workbuf + sd->workbuf_data_key_offset); + k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset); TEST_EQ(k->algorithm, 7, "data key algorithm"); TEST_EQ(k->key_version, 2, "data key version"); TEST_EQ(k->key_size, sizeof(mock_vblock.k.data_key_data), "data key size"); - TEST_EQ(memcmp(cc.workbuf + sd->workbuf_data_key_offset + + TEST_EQ(memcmp(ctx.workbuf + sd->workbuf_data_key_offset + k->key_offset, mock_vblock.k.data_key_data, sizeof(mock_vblock.k.data_key_data)), 0, "data key data"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_data_key_offset + sd->workbuf_data_key_size), "workbuf used after"); @@ -277,112 +277,112 @@ static void load_kernel_keyblock_tests(void) /* Test failures */ reset_common_data(FOR_KEYBLOCK); mock_unpack_key_retval = VB2_ERROR_MOCK; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_MOCK, "Kernel keyblock unpack key"); reset_common_data(FOR_KEYBLOCK); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sizeof(*kb)); - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_KERNEL_KEYBLOCK_WORKBUF_HEADER, "Kernel keyblock workbuf header"); reset_common_data(FOR_KEYBLOCK); mock_read_res_fail_on_call = 1; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_MOCK, "Kernel keyblock read header"); reset_common_data(FOR_KEYBLOCK); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(kb->keyblock_size); - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_KERNEL_KEYBLOCK_WORKBUF, "Kernel keyblock workbuf"); reset_common_data(FOR_KEYBLOCK); mock_read_res_fail_on_call = 2; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_MOCK, "Kernel keyblock read"); /* Normally, require signed keyblock */ reset_common_data(FOR_KEYBLOCK); mock_verify_keyblock_retval = VB2_ERROR_MOCK; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_MOCK, "Verify keyblock"); /* Not in dev mode */ reset_common_data(FOR_KEYBLOCK); - cc.flags |= VB2_CONTEXT_DEVELOPER_MODE; + ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE; mock_verify_keyblock_retval = VB2_ERROR_MOCK; - TEST_SUCC(vb2_load_kernel_keyblock(&cc), "Kernel keyblock hash good"); + TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock hash good"); TEST_EQ(sd->flags & VB2_SD_FLAG_KERNEL_SIGNED, 0, " Kernel signed"); /* But we do in dev+rec mode */ reset_common_data(FOR_KEYBLOCK); - cc.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE; + ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE; mock_verify_keyblock_retval = VB2_ERROR_MOCK; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_MOCK, "Kernel keyblock dev+rec"); /* Test keyblock flags matching mode */ reset_common_data(FOR_KEYBLOCK); kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_DEVELOPER_0; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_KERNEL_KEYBLOCK_DEV_FLAG, "Kernel keyblock dev only"); reset_common_data(FOR_KEYBLOCK); kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_RECOVERY_0; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_KERNEL_KEYBLOCK_REC_FLAG, "Kernel keyblock rec only"); reset_common_data(FOR_KEYBLOCK); kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_RECOVERY_1; - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_KERNEL_KEYBLOCK_REC_FLAG, "Kernel keyblock not rec"); reset_common_data(FOR_KEYBLOCK); kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_DEVELOPER_0; kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_RECOVERY_0; - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_KERNEL_KEYBLOCK_DEV_FLAG, "Kernel keyblock rec but not dev+rec"); reset_common_data(FOR_KEYBLOCK); kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_DEVELOPER_0; kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_RECOVERY_0; - cc.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE; - TEST_SUCC(vb2_load_kernel_keyblock(&cc), + ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE; + TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock flags dev+rec"); /* System in dev mode ignores flags */ reset_common_data(FOR_KEYBLOCK); - cc.flags |= VB2_CONTEXT_DEVELOPER_MODE; + ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE; kb->keyblock_flags = 0; - TEST_SUCC(vb2_load_kernel_keyblock(&cc), "Kernel keyblock dev flags"); + TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock dev flags"); /* Test rollback */ reset_common_data(FOR_KEYBLOCK); kb->data_key.key_version = 0x10000; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_KERNEL_KEYBLOCK_VERSION_RANGE, "Kernel keyblock version range"); reset_common_data(FOR_KEYBLOCK); kb->data_key.key_version = 1; - TEST_EQ(vb2_load_kernel_keyblock(&cc), + TEST_EQ(vb2_load_kernel_keyblock(&ctx), VB2_ERROR_KERNEL_KEYBLOCK_VERSION_ROLLBACK, "Kernel keyblock rollback"); /* Rollback ok in developer mode */ reset_common_data(FOR_KEYBLOCK); kb->data_key.key_version = 1; - cc.flags |= VB2_CONTEXT_DEVELOPER_MODE; - TEST_SUCC(vb2_load_kernel_keyblock(&cc), + ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE; + TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock rollback dev"); /* @@ -391,8 +391,8 @@ static void load_kernel_keyblock_tests(void) */ reset_common_data(FOR_KEYBLOCK); kb->data_key.key_version = 1; - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; - TEST_SUCC(vb2_load_kernel_keyblock(&cc), + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; + TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock rollback rec"); } @@ -404,13 +404,13 @@ static void load_kernel_preamble_tests(void) /* Test successful call */ reset_common_data(FOR_PREAMBLE); - wb_used_before = cc.workbuf_used; - TEST_SUCC(vb2_load_kernel_preamble(&cc), "preamble good"); + wb_used_before = ctx.workbuf_used; + TEST_SUCC(vb2_load_kernel_preamble(&ctx), "preamble good"); TEST_EQ(sd->kernel_version, 0x20002, "combined version"); TEST_EQ(sd->workbuf_preamble_offset, wb_used_before, "preamble offset"); TEST_EQ(sd->workbuf_preamble_size, pre->preamble_size, "preamble size"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_preamble_offset + sd->workbuf_preamble_size), "workbuf used"); @@ -418,57 +418,57 @@ static void load_kernel_preamble_tests(void) /* Expected failures */ reset_common_data(FOR_PREAMBLE); sd->workbuf_data_key_size = 0; - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_KERNEL_PREAMBLE2_DATA_KEY, "preamble no data key"); reset_common_data(FOR_PREAMBLE); mock_unpack_key_retval = VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM; - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM, "preamble unpack data key"); reset_common_data(FOR_PREAMBLE); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sizeof(struct vb2_kernel_preamble)); - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_KERNEL_PREAMBLE2_WORKBUF_HEADER, "preamble not enough workbuf for header"); reset_common_data(FOR_PREAMBLE); sd->vblock_preamble_offset = sizeof(mock_vblock); - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_EX_READ_RESOURCE_SIZE, "preamble read header"); reset_common_data(FOR_PREAMBLE); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sizeof(mock_vblock.p)); - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_KERNEL_PREAMBLE2_WORKBUF, "preamble not enough workbuf"); reset_common_data(FOR_PREAMBLE); pre->preamble_size = sizeof(mock_vblock); - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_EX_READ_RESOURCE_SIZE, "preamble read full"); reset_common_data(FOR_PREAMBLE); mock_verify_preamble_retval = VB2_ERROR_MOCK; - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_MOCK, "preamble verify"); reset_common_data(FOR_PREAMBLE); pre->kernel_version = 0x10000; - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_KERNEL_PREAMBLE_VERSION_RANGE, "preamble version range"); reset_common_data(FOR_PREAMBLE); pre->kernel_version = 1; - TEST_EQ(vb2_load_kernel_preamble(&cc), + TEST_EQ(vb2_load_kernel_preamble(&ctx), VB2_ERROR_KERNEL_PREAMBLE_VERSION_ROLLBACK, "preamble version rollback"); } diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c index 995e0fc6..84e8e96e 100644 --- a/tests/vb20_misc_tests.c +++ b/tests/vb20_misc_tests.c @@ -20,7 +20,7 @@ /* Common context for tests */ static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE] __attribute__ ((aligned (VB2_WORKBUF_ALIGN))); -static struct vb2_context cc; +static struct vb2_context ctx; static struct vb2_shared_data *sd; /* Mocked function data */ @@ -64,17 +64,17 @@ static void reset_common_data(enum reset_type t) memset(workbuf, 0xaa, sizeof(workbuf)); - memset(&cc, 0, sizeof(cc)); - cc.workbuf = workbuf; - cc.workbuf_size = sizeof(workbuf); + memset(&ctx, 0, sizeof(ctx)); + ctx.workbuf = workbuf; + ctx.workbuf_size = sizeof(workbuf); - vb2_init_context(&cc); - sd = vb2_get_sd(&cc); + vb2_init_context(&ctx); + sd = vb2_get_sd(&ctx); - vb2_nv_init(&cc); + vb2_nv_init(&ctx); - vb2_secdata_create(&cc); - vb2_secdata_init(&cc); + vb2_secdata_create(&ctx); + vb2_secdata_init(&ctx); mock_read_res_fail_on_call = 0; mock_unpack_key_retval = VB2_SUCCESS; @@ -83,7 +83,7 @@ static void reset_common_data(enum reset_type t) /* Set up mock data for verifying keyblock */ sd->fw_version_secdata = 0x20002; - vb2_secdata_set(&cc, VB2_SECDATA_VERSIONS, sd->fw_version_secdata); + vb2_secdata_set(&ctx, VB2_SECDATA_VERSIONS, sd->fw_version_secdata); sd->gbb_rootkey_offset = vb2_offset_of(&mock_gbb, &mock_gbb.rootkey); sd->gbb_rootkey_size = sizeof(mock_gbb.rootkey_data); @@ -109,12 +109,12 @@ static void reset_common_data(enum reset_type t) /* If verifying preamble, verify keyblock first to set up data key */ if (t == FOR_PREAMBLE) - vb2_load_fw_keyblock(&cc); + vb2_load_fw_keyblock(&ctx); }; /* Mocked functions */ -int vb2ex_read_resource(struct vb2_context *ctx, +int vb2ex_read_resource(struct vb2_context *c, enum vb2_resource_index index, uint32_t offset, void *buf, @@ -180,102 +180,102 @@ static void verify_keyblock_tests(void) /* Test successful call */ reset_common_data(FOR_KEYBLOCK); - wb_used_before = cc.workbuf_used; - TEST_SUCC(vb2_load_fw_keyblock(&cc), "keyblock verify"); + wb_used_before = ctx.workbuf_used; + TEST_SUCC(vb2_load_fw_keyblock(&ctx), "keyblock verify"); TEST_EQ(sd->fw_version, 0x20000, "keyblock version"); TEST_EQ(sd->vblock_preamble_offset, sizeof(mock_vblock.k), "preamble offset"); TEST_EQ(sd->workbuf_data_key_offset, wb_used_before, "keyblock data key offset"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_data_key_offset + sd->workbuf_data_key_size), "workbuf used"); /* Make sure data key was properly saved */ - k = (struct vb2_packed_key *)(cc.workbuf + sd->workbuf_data_key_offset); + k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset); TEST_EQ(k->algorithm, 7, "data key algorithm"); TEST_EQ(k->key_version, 2, "data key version"); TEST_EQ(k->key_size, sizeof(mock_vblock.k.data_key_data), "data key size"); - TEST_EQ(memcmp(cc.workbuf + sd->workbuf_data_key_offset + + TEST_EQ(memcmp(ctx.workbuf + sd->workbuf_data_key_offset + k->key_offset, mock_vblock.k.data_key_data, sizeof(mock_vblock.k.data_key_data)), 0, "data key data"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_data_key_offset + sd->workbuf_data_key_size), "workbuf used after"); /* Test failures */ reset_common_data(FOR_KEYBLOCK); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sd->gbb_rootkey_size); - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_FW_KEYBLOCK_WORKBUF_ROOT_KEY, "keyblock not enough workbuf for root key"); reset_common_data(FOR_KEYBLOCK); sd->gbb_rootkey_size = sizeof(mock_gbb); - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_EX_READ_RESOURCE_SIZE, "keyblock read root key"); reset_common_data(FOR_KEYBLOCK); mock_unpack_key_retval = VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM; - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM, "keyblock unpack root key"); reset_common_data(FOR_KEYBLOCK); - cc.workbuf_used = cc.workbuf_size - + ctx.workbuf_used = ctx.workbuf_size - vb2_wb_round_up(sd->gbb_rootkey_size); - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_FW_KEYBLOCK_WORKBUF_HEADER, "keyblock not enough workbuf for header"); reset_common_data(FOR_KEYBLOCK); mock_read_res_fail_on_call = 2; - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_EX_READ_RESOURCE_INDEX, "keyblock read keyblock header"); reset_common_data(FOR_KEYBLOCK); - cc.workbuf_used = cc.workbuf_size - + ctx.workbuf_used = ctx.workbuf_size - vb2_wb_round_up(sd->gbb_rootkey_size) - vb2_wb_round_up(sizeof(struct vb2_keyblock)); - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_FW_KEYBLOCK_WORKBUF, "keyblock not enough workbuf for entire keyblock"); reset_common_data(FOR_KEYBLOCK); kb->keyblock_size = sizeof(mock_vblock) + 1; - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_EX_READ_RESOURCE_SIZE, "keyblock read keyblock"); reset_common_data(FOR_KEYBLOCK); mock_verify_keyblock_retval = VB2_ERROR_KEYBLOCK_MAGIC; - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_KEYBLOCK_MAGIC, "keyblock verify keyblock"); reset_common_data(FOR_KEYBLOCK); kb->data_key.key_version = 0x10000; - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_FW_KEYBLOCK_VERSION_RANGE, "keyblock version range"); reset_common_data(FOR_KEYBLOCK); kb->data_key.key_version = 1; - TEST_EQ(vb2_load_fw_keyblock(&cc), + TEST_EQ(vb2_load_fw_keyblock(&ctx), VB2_ERROR_FW_KEYBLOCK_VERSION_ROLLBACK, "keyblock rollback"); reset_common_data(FOR_KEYBLOCK); kb->data_key.key_version = 1; sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK; - TEST_SUCC(vb2_load_fw_keyblock(&cc), "keyblock rollback with GBB flag"); + TEST_SUCC(vb2_load_fw_keyblock(&ctx), "keyblock rollback with GBB flag"); } static void verify_preamble_tests(void) @@ -286,13 +286,13 @@ static void verify_preamble_tests(void) /* Test successful call */ reset_common_data(FOR_PREAMBLE); - wb_used_before = cc.workbuf_used; - TEST_SUCC(vb2_load_fw_preamble(&cc), "preamble good"); + wb_used_before = ctx.workbuf_used; + TEST_SUCC(vb2_load_fw_preamble(&ctx), "preamble good"); TEST_EQ(sd->fw_version, 0x20002, "combined version"); TEST_EQ(sd->workbuf_preamble_offset, wb_used_before, "preamble offset"); TEST_EQ(sd->workbuf_preamble_size, pre->preamble_size, "preamble size"); - TEST_EQ(cc.workbuf_used, + TEST_EQ(ctx.workbuf_used, vb2_wb_round_up(sd->workbuf_preamble_offset + sd->workbuf_preamble_size), "workbuf used"); @@ -300,88 +300,88 @@ static void verify_preamble_tests(void) /* Expected failures */ reset_common_data(FOR_PREAMBLE); sd->workbuf_data_key_size = 0; - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_FW_PREAMBLE2_DATA_KEY, "preamble no data key"); reset_common_data(FOR_PREAMBLE); mock_unpack_key_retval = VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM; - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM, "preamble unpack data key"); reset_common_data(FOR_PREAMBLE); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sizeof(struct vb2_fw_preamble)); - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_FW_PREAMBLE2_WORKBUF_HEADER, "preamble not enough workbuf for header"); reset_common_data(FOR_PREAMBLE); sd->vblock_preamble_offset = sizeof(mock_vblock); - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_EX_READ_RESOURCE_SIZE, "preamble read header"); reset_common_data(FOR_PREAMBLE); - cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN - + ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN - vb2_wb_round_up(sizeof(mock_vblock.p)); - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_FW_PREAMBLE2_WORKBUF, "preamble not enough workbuf"); reset_common_data(FOR_PREAMBLE); pre->preamble_size = sizeof(mock_vblock); - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_EX_READ_RESOURCE_SIZE, "preamble read full"); reset_common_data(FOR_PREAMBLE); mock_verify_preamble_retval = VB2_ERROR_PREAMBLE_SIG_INVALID; - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_PREAMBLE_SIG_INVALID, "preamble verify"); reset_common_data(FOR_PREAMBLE); pre->firmware_version = 0x10000; - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_FW_PREAMBLE_VERSION_RANGE, "preamble version range"); reset_common_data(FOR_PREAMBLE); pre->firmware_version = 1; - TEST_EQ(vb2_load_fw_preamble(&cc), + TEST_EQ(vb2_load_fw_preamble(&ctx), VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK, "preamble version rollback"); reset_common_data(FOR_PREAMBLE); pre->firmware_version = 1; sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK; - TEST_SUCC(vb2_load_fw_preamble(&cc), "version rollback with GBB flag"); + TEST_SUCC(vb2_load_fw_preamble(&ctx), "version rollback with GBB flag"); reset_common_data(FOR_PREAMBLE); pre->firmware_version = 3; - TEST_SUCC(vb2_load_fw_preamble(&cc), + TEST_SUCC(vb2_load_fw_preamble(&ctx), "preamble version roll forward"); - vb2_secdata_get(&cc, VB2_SECDATA_VERSIONS, &v); + vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v); TEST_EQ(v, 0x20003, "roll forward"); /* Newer version without result success doesn't roll forward */ reset_common_data(FOR_PREAMBLE); pre->firmware_version = 3; sd->last_fw_result = VB2_FW_RESULT_UNKNOWN; - TEST_SUCC(vb2_load_fw_preamble(&cc), + TEST_SUCC(vb2_load_fw_preamble(&ctx), "preamble version no roll forward 1"); - vb2_secdata_get(&cc, VB2_SECDATA_VERSIONS, &v); + vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v); TEST_EQ(v, 0x20002, "no roll forward"); /* Newer version with success but for other slot doesn't roll forward */ reset_common_data(FOR_PREAMBLE); pre->firmware_version = 3; sd->last_fw_slot = 1; - TEST_SUCC(vb2_load_fw_preamble(&cc), + TEST_SUCC(vb2_load_fw_preamble(&ctx), "preamble version no roll forward 2"); - vb2_secdata_get(&cc, VB2_SECDATA_VERSIONS, &v); + vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v); TEST_EQ(v, 0x20002, "no roll forward"); } diff --git a/tests/vb20_verify_fw.c b/tests/vb20_verify_fw.c index 5025859c..2e098f38 100644 --- a/tests/vb20_verify_fw.c +++ b/tests/vb20_verify_fw.c @@ -20,7 +20,7 @@ const char *body_fname; * Local implementation which reads resources from individual files. Could be * more elegant and read from bios.bin, if we understood the fmap. */ -int vb2ex_read_resource(struct vb2_context *ctx, +int vb2ex_read_resource(struct vb2_context *c, enum vb2_resource_index index, uint32_t offset, void *buf, @@ -60,7 +60,7 @@ int vb2ex_read_resource(struct vb2_context *ctx, return got_size == size ? VB2_SUCCESS : VB2_ERROR_UNKNOWN; } -int vb2ex_tpm_clear_owner(struct vb2_context *ctx) +int vb2ex_tpm_clear_owner(struct vb2_context *c) { // TODO: implement return VB2_SUCCESS; @@ -69,24 +69,24 @@ int vb2ex_tpm_clear_owner(struct vb2_context *ctx) /** * Save non-volatile and/or secure data if needed. */ -static void save_if_needed(struct vb2_context *ctx) +static void save_if_needed(struct vb2_context *c) { - if (ctx->flags & VB2_CONTEXT_NVDATA_CHANGED) { + if (c->flags & VB2_CONTEXT_NVDATA_CHANGED) { // TODO: implement - ctx->flags &= ~VB2_CONTEXT_NVDATA_CHANGED; + c->flags &= ~VB2_CONTEXT_NVDATA_CHANGED; } - if (ctx->flags & VB2_CONTEXT_SECDATA_CHANGED) { + if (c->flags & VB2_CONTEXT_SECDATA_CHANGED) { // TODO: implement - ctx->flags &= ~VB2_CONTEXT_SECDATA_CHANGED; + c->flags &= ~VB2_CONTEXT_SECDATA_CHANGED; } } /** * Verify firmware body */ -static int hash_body(struct vb2_context *ctx) +static int hash_body(struct vb2_context *c) { uint32_t expect_size; uint8_t block[8192]; @@ -100,7 +100,7 @@ static int hash_body(struct vb2_context *ctx) return VB2_ERROR_TEST_INPUT_FILE; /* Start the body hash */ - rv = vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY, &expect_size); + rv = vb2api_init_hash(c, VB2_HASH_TAG_FW_BODY, &expect_size); if (rv) { fclose(f); return rv; @@ -120,7 +120,7 @@ static int hash_body(struct vb2_context *ctx) break; /* Hash it */ - rv = vb2api_extend_hash(ctx, block, size); + rv = vb2api_extend_hash(c, block, size); if (rv) { fclose(f); return rv; @@ -132,7 +132,7 @@ static int hash_body(struct vb2_context *ctx) fclose(f); /* Check the result */ - rv = vb2api_check_hash(ctx); + rv = vb2api_check_hash(c); if (rv) return rv; diff --git a/tests/vb2_api_tests.c b/tests/vb2_api_tests.c index d45f7451..97fc6d97 100644 --- a/tests/vb2_api_tests.c +++ b/tests/vb2_api_tests.c @@ -19,7 +19,7 @@ /* Common context for tests */ static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE] __attribute__ ((aligned (VB2_WORKBUF_ALIGN))); -static struct vb2_context cc; +static struct vb2_context ctx; static struct vb2_shared_data *sd; const char mock_body[320] = "Mock body"; @@ -49,17 +49,17 @@ static void reset_common_data(enum reset_type t) { memset(workbuf, 0xaa, sizeof(workbuf)); - memset(&cc, 0, sizeof(cc)); - cc.workbuf = workbuf; - cc.workbuf_size = sizeof(workbuf); + memset(&ctx, 0, sizeof(ctx)); + ctx.workbuf = workbuf; + ctx.workbuf_size = sizeof(workbuf); - vb2_init_context(&cc); - sd = vb2_get_sd(&cc); + vb2_init_context(&ctx); + sd = vb2_get_sd(&ctx); - vb2_nv_init(&cc); + vb2_nv_init(&ctx); - vb2_secdata_create(&cc); - vb2_secdata_init(&cc); + vb2_secdata_create(&ctx); + vb2_secdata_init(&ctx); force_dev_mode = 0; retval_vb2_fw_parse_gbb = VB2_SUCCESS; @@ -73,24 +73,24 @@ static void reset_common_data(enum reset_type t) /* Mocked functions */ -int vb2_fw_parse_gbb(struct vb2_context *ctx) +int vb2_fw_parse_gbb(struct vb2_context *c) { return retval_vb2_fw_parse_gbb; } -int vb2_check_dev_switch(struct vb2_context *ctx) +int vb2_check_dev_switch(struct vb2_context *c) { if (force_dev_mode) sd->flags |= VB2_SD_FLAG_DEV_MODE_ENABLED; return retval_vb2_check_dev_switch; } -int vb2_check_tpm_clear(struct vb2_context *ctx) +int vb2_check_tpm_clear(struct vb2_context *c) { return retval_vb2_check_tpm_clear; } -int vb2_select_fw_slot(struct vb2_context *ctx) +int vb2_select_fw_slot(struct vb2_context *c) { return retval_vb2_select_fw_slot; } @@ -102,173 +102,173 @@ static void misc_tests(void) /* Test secdata passthru functions */ reset_common_data(FOR_MISC); /* Corrupt secdata so initial check will fail */ - cc.secdata[0] ^= 0x42; - TEST_EQ(vb2api_secdata_check(&cc), VB2_ERROR_SECDATA_CRC, + ctx.secdata[0] ^= 0x42; + TEST_EQ(vb2api_secdata_check(&ctx), VB2_ERROR_SECDATA_CRC, "secdata check"); - TEST_SUCC(vb2api_secdata_create(&cc), "secdata create"); - TEST_SUCC(vb2api_secdata_check(&cc), "secdata check 2"); + TEST_SUCC(vb2api_secdata_create(&ctx), "secdata create"); + TEST_SUCC(vb2api_secdata_check(&ctx), "secdata check 2"); /* Test fail passthru */ reset_common_data(FOR_MISC); - vb2api_fail(&cc, 12, 34); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + vb2api_fail(&ctx, 12, 34); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 12, "vb2api_fail request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_SUBCODE), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE), 34, "vb2api_fail subcode"); } static void phase1_tests(void) { reset_common_data(FOR_MISC); - TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 good"); + TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 good"); TEST_EQ(sd->recovery_reason, 0, " not recovery"); - TEST_EQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag"); - TEST_EQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag"); - TEST_EQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT, + 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"); reset_common_data(FOR_MISC); retval_vb2_fw_parse_gbb = VB2_ERROR_GBB_MAGIC; - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY, + 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(cc.flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag"); - TEST_NEQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag"); /* Dev switch error in normal mode reboots to recovery */ reset_common_data(FOR_MISC); retval_vb2_check_dev_switch = VB2_ERROR_MOCK; - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_MOCK, "phase1 dev switch"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_MOCK, "phase1 dev switch"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), VB2_RECOVERY_DEV_SWITCH, " recovery request"); /* Dev switch error already in recovery mode just proceeds */ reset_common_data(FOR_MISC); - vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED); + vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED); retval_vb2_check_dev_switch = VB2_ERROR_MOCK; - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY, + TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY, "phase1 dev switch error in recovery"); TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED, " recovery reason"); /* Check that DISPLAY_AVAILABLE gets set on recovery mode. */ - TEST_NEQ(cc.flags & VB2_CONTEXT_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"); reset_common_data(FOR_MISC); - cc.secdata[0] ^= 0x42; - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY, + ctx.secdata[0] ^= 0x42; + TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY, "phase1 secdata"); TEST_EQ(sd->recovery_reason, VB2_RECOVERY_SECDATA_INIT, " recovery reason"); - TEST_NEQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag"); - TEST_NEQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag"); /* Test secdata-requested reboot */ reset_common_data(FOR_MISC); - cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT; - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_SECDATA_REBOOT, + ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT; + TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT, "phase1 secdata reboot normal"); TEST_EQ(sd->recovery_reason, 0, " recovery reason"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT), 1, " tpm reboot request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, " recovery request"); reset_common_data(FOR_MISC); - vb2_nv_set(&cc, VB2_NV_TPM_REQUESTED_REBOOT, 1); - TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 secdata reboot back normal"); + vb2_nv_set(&ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1); + TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 secdata reboot back normal"); TEST_EQ(sd->recovery_reason, 0, " recovery reason"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT), 0, " tpm reboot request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, " recovery request"); reset_common_data(FOR_MISC); - cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT; - memset(cc.secdata, 0, sizeof(cc.secdata)); - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_SECDATA_REBOOT, + ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT; + memset(ctx.secdata, 0, sizeof(ctx.secdata)); + TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT, "phase1 secdata reboot normal, secdata blank"); TEST_EQ(sd->recovery_reason, 0, " recovery reason"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT), 1, " tpm reboot request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, " recovery request"); reset_common_data(FOR_MISC); - cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT; - vb2_nv_set(&cc, VB2_NV_TPM_REQUESTED_REBOOT, 1); - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY, + 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 reboot normal again"); TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_TPM_REBOOT, " recovery reason"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT), 1, " tpm reboot request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, " recovery request"); reset_common_data(FOR_MISC); - cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT; - vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED); - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_SECDATA_REBOOT, + 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 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(&cc, VB2_NV_TPM_REQUESTED_REBOOT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT), 1, " tpm reboot request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), VB2_RECOVERY_RO_UNSPECIFIED, " recovery request not cleared"); reset_common_data(FOR_MISC); - vb2_nv_set(&cc, VB2_NV_TPM_REQUESTED_REBOOT, 1); - vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED); - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY, + 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 reboot back recovery"); TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED, " recovery reason"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT), 0, " tpm reboot request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 0, + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, " recovery request cleared"); reset_common_data(FOR_MISC); - cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT; - vb2_nv_set(&cc, VB2_NV_TPM_REQUESTED_REBOOT, 1); - vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED); - TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY, + 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 reboot recovery again"); TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED, " recovery reason"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT), 1, " tpm reboot request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 0, + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, " recovery request cleared"); /* Cases for checking DISPLAY_INIT and DISPLAY_AVAILABLE. */ reset_common_data(FOR_MISC); - cc.flags |= VB2_CONTEXT_DISPLAY_INIT; - TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 with DISPLAY_INIT"); - TEST_NEQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT, + 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"); reset_common_data(FOR_MISC); - vb2_nv_set(&cc, VB2_NV_DISPLAY_REQUEST, 1); - TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 with DISPLAY_REQUEST"); - TEST_NEQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT, + 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"); reset_common_data(FOR_MISC); force_dev_mode = 1; - TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 in dev mode"); - TEST_NEQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT, + 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"); @@ -277,40 +277,40 @@ static void phase1_tests(void) static void phase2_tests(void) { reset_common_data(FOR_MISC); - TEST_SUCC(vb2api_fw_phase2(&cc), "phase2 good"); - TEST_EQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag"); - TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, " slot b flag"); + 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); - cc.flags |= VB2_CONTEXT_DEVELOPER_MODE; - TEST_SUCC(vb2api_fw_phase2(&cc), "phase2 dev"); - TEST_NEQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag"); + 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(&cc), VB2_ERROR_MOCK, "phase2 tpm clear"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + 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(&cc), VB2_ERROR_MOCK, "phase2 slot"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + 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); - cc.flags |= VB2_CONTEXT_S3_RESUME; - cc.flags |= VB2_CONTEXT_DEVELOPER_MODE; - TEST_SUCC(vb2api_fw_phase2(&cc), "phase2 s3 dev"); - TEST_EQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag"); - TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, " slot b flag"); + 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); - cc.flags |= VB2_CONTEXT_S3_RESUME; - vb2_nv_set(&cc, VB2_NV_FW_TRIED, 1); - TEST_SUCC(vb2api_fw_phase2(&cc), "phase2 s3"); - TEST_NEQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, " slot b flag"); + 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) @@ -325,7 +325,7 @@ static void get_pcr_digest_tests(void) digest_size = sizeof(digest); memset(digest, 0, sizeof(digest)); TEST_SUCC(vb2api_get_pcr_digest( - &cc, BOOT_MODE_PCR, digest, &digest_size), + &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), @@ -334,7 +334,7 @@ static void get_pcr_digest_tests(void) digest_size = sizeof(digest); memset(digest, 0, sizeof(digest)); TEST_SUCC(vb2api_get_pcr_digest( - &cc, HWID_DIGEST_PCR, digest, &digest_size), + &ctx, HWID_DIGEST_PCR, digest, &digest_size), "HWID_DIGEST_PCR"); TEST_EQ(digest_size, VB2_GBB_HWID_DIGEST_SIZE, "HWID_DIGEST_PCR digest size"); @@ -342,12 +342,12 @@ static void get_pcr_digest_tests(void) "HWID_DIGEST_PCR digest"); digest_size = 1; - TEST_EQ(vb2api_get_pcr_digest(&cc, BOOT_MODE_PCR, digest, &digest_size), + 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( - &cc, HWID_DIGEST_PCR + 1, digest, &digest_size), + &ctx, HWID_DIGEST_PCR + 1, digest, &digest_size), VB2_ERROR_API_PCR_DIGEST, "invalid enum vb2_pcr_digest"); } diff --git a/tests/vb2_misc_tests.c b/tests/vb2_misc_tests.c index 781b0847..0f3f0c58 100644 --- a/tests/vb2_misc_tests.c +++ b/tests/vb2_misc_tests.c @@ -17,7 +17,7 @@ /* Common context for tests */ static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE] __attribute__ ((aligned (VB2_WORKBUF_ALIGN))); -static struct vb2_context cc; +static struct vb2_context ctx; static struct vb2_shared_data *sd; /* Mocked function data */ @@ -32,17 +32,17 @@ static void reset_common_data(void) { memset(workbuf, 0xaa, sizeof(workbuf)); - memset(&cc, 0, sizeof(cc)); - cc.workbuf = workbuf; - cc.workbuf_size = sizeof(workbuf); + memset(&ctx, 0, sizeof(ctx)); + ctx.workbuf = workbuf; + ctx.workbuf_size = sizeof(workbuf); - vb2_init_context(&cc); - sd = vb2_get_sd(&cc); + vb2_init_context(&ctx); + sd = vb2_get_sd(&ctx); - vb2_nv_init(&cc); + vb2_nv_init(&ctx); - vb2_secdata_create(&cc); - vb2_secdata_init(&cc); + vb2_secdata_create(&ctx); + vb2_secdata_init(&ctx); mock_tpm_clear_called = 0; mock_tpm_clear_retval = VB2_SUCCESS; @@ -50,7 +50,7 @@ static void reset_common_data(void) /* Mocked functions */ -int vb2ex_read_resource(struct vb2_context *ctx, +int vb2ex_read_resource(struct vb2_context *c, enum vb2_resource_index index, uint32_t offset, void *buf, @@ -66,7 +66,7 @@ int vb2ex_read_resource(struct vb2_context *ctx, return VB2_SUCCESS; } -int vb2ex_tpm_clear_owner(struct vb2_context *ctx) +int vb2ex_tpm_clear_owner(struct vb2_context *c) { mock_tpm_clear_called++; @@ -148,13 +148,13 @@ static void misc_tests(void) struct vb2_workbuf wb; reset_common_data(); - cc.workbuf_used = VB2_WORKBUF_ALIGN; + ctx.workbuf_used = VB2_WORKBUF_ALIGN; - vb2_workbuf_from_ctx(&cc, &wb); + vb2_workbuf_from_ctx(&ctx, &wb); TEST_PTR_EQ(wb.buf, workbuf + VB2_WORKBUF_ALIGN, "vb_workbuf_from_ctx() buf"); - TEST_EQ(wb.size, cc.workbuf_size - VB2_WORKBUF_ALIGN, + TEST_EQ(wb.size, ctx.workbuf_size - VB2_WORKBUF_ALIGN, "vb_workbuf_from_ctx() size"); } @@ -182,52 +182,52 @@ static void gbb_tests(void) mock_resource_index = VB2_RES_GBB; mock_resource_ptr = &gbb; mock_resource_size = sizeof(gbb); - TEST_SUCC(vb2_read_gbb_header(&cc, &gbbdest), "read gbb header good"); + TEST_SUCC(vb2_read_gbb_header(&ctx, &gbbdest), "read gbb header good"); TEST_SUCC(memcmp(&gbb, &gbbdest, sizeof(gbb)), "read gbb contents"); mock_resource_index = VB2_RES_GBB + 1; - TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest), + TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest), VB2_ERROR_EX_READ_RESOURCE_INDEX, "read gbb header missing"); mock_resource_index = VB2_RES_GBB; gbb.signature[0]++; - TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest), + TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest), VB2_ERROR_GBB_MAGIC, "read gbb header bad magic"); gbb.signature[0]--; gbb.major_version = VB2_GBB_MAJOR_VER + 1; - TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest), + TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest), VB2_ERROR_GBB_VERSION, "read gbb header major version"); gbb.major_version = VB2_GBB_MAJOR_VER; gbb.minor_version = VB2_GBB_MINOR_VER + 1; - TEST_SUCC(vb2_read_gbb_header(&cc, &gbbdest), + TEST_SUCC(vb2_read_gbb_header(&ctx, &gbbdest), "read gbb header minor++"); gbb.minor_version = 1; - TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest), + TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest), VB2_ERROR_GBB_TOO_OLD, "read gbb header 1.1 fails"); gbb.minor_version = 0; - TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest), + TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest), VB2_ERROR_GBB_TOO_OLD, "read gbb header 1.0 fails"); gbb.minor_version = VB2_GBB_MINOR_VER; gbb.header_size--; - TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest), + TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest), VB2_ERROR_GBB_HEADER_SIZE, "read gbb header size"); - TEST_EQ(vb2_fw_parse_gbb(&cc), + TEST_EQ(vb2_fw_parse_gbb(&ctx), VB2_ERROR_GBB_HEADER_SIZE, "parse gbb failure"); gbb.header_size++; /* Parse GBB */ - TEST_SUCC(vb2_fw_parse_gbb(&cc), "parse gbb"); + TEST_SUCC(vb2_fw_parse_gbb(&ctx), "parse gbb"); TEST_EQ(sd->gbb_flags, gbb.flags, "gbb flags"); TEST_EQ(sd->gbb_rootkey_offset, gbb.rootkey_offset, "rootkey offset"); TEST_EQ(sd->gbb_rootkey_size, gbb.rootkey_size, "rootkey size"); /* Workbuf failure */ reset_common_data(); - cc.workbuf_used = cc.workbuf_size - 4; - TEST_EQ(vb2_fw_parse_gbb(&cc), + ctx.workbuf_used = ctx.workbuf_size - 4; + TEST_EQ(vb2_fw_parse_gbb(&ctx), VB2_ERROR_GBB_WORKBUF, "parse gbb no workbuf"); } @@ -236,34 +236,34 @@ static void fail_tests(void) /* Early fail (before even NV init) */ reset_common_data(); sd->status &= ~VB2_SD_STATUS_NV_INIT; - vb2_fail(&cc, 1, 2); + vb2_fail(&ctx, 1, 2); TEST_NEQ(sd->status & VB2_SD_STATUS_NV_INIT, 0, "vb2_fail inits NV"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 1, "vb2_fail request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_SUBCODE), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE), 2, "vb2_fail subcode"); /* Repeated fail doesn't overwrite the error code */ - vb2_fail(&cc, 3, 4); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + vb2_fail(&ctx, 3, 4); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 1, "vb2_fail repeat"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_SUBCODE), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE), 2, "vb2_fail repeat2"); /* Fail with other slot good doesn't trigger recovery */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_TRY_COUNT, 3); - vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_UNKNOWN); + vb2_nv_set(&ctx, VB2_NV_TRY_COUNT, 3); + vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_UNKNOWN); sd->status |= VB2_SD_STATUS_CHOSE_SLOT; sd->fw_slot = 0; sd->last_fw_slot = 1; sd->last_fw_result = VB2_FW_RESULT_UNKNOWN; - vb2_fail(&cc, 5, 6); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 0, "vb2_failover"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT), + vb2_fail(&ctx, 5, 6); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "vb2_failover"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT), VB2_FW_RESULT_FAILURE, "vb2_fail this fw"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_COUNT), 0, "vb2_fail use up tries"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_NEXT), 1, "vb2_fail try other slot"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_COUNT), 0, "vb2_fail use up tries"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 1, "vb2_fail try other slot"); /* Fail with other slot already failing triggers recovery */ reset_common_data(); @@ -271,50 +271,50 @@ static void fail_tests(void) sd->fw_slot = 1; sd->last_fw_slot = 0; sd->last_fw_result = VB2_FW_RESULT_FAILURE; - vb2_fail(&cc, 7, 8); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 7, + vb2_fail(&ctx, 7, 8); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 7, "vb2_fail both slots bad"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT), VB2_FW_RESULT_FAILURE, "vb2_fail this fw"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_NEXT), 0, "vb2_fail try other slot"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 0, "vb2_fail try other slot"); } static void recovery_tests(void) { /* No recovery */ reset_common_data(); - vb2_check_recovery(&cc); + vb2_check_recovery(&ctx); TEST_EQ(sd->recovery_reason, 0, "No recovery reason"); TEST_EQ(sd->flags & VB2_SD_FLAG_MANUAL_RECOVERY, 0, "Not manual recovery"); - TEST_EQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE, + TEST_EQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "Not recovery mode"); /* From request */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, 3); - vb2_check_recovery(&cc); + vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, 3); + vb2_check_recovery(&ctx); TEST_EQ(sd->recovery_reason, 3, "Recovery reason from request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 0, "NV cleared"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "NV cleared"); TEST_EQ(sd->flags & VB2_SD_FLAG_MANUAL_RECOVERY, 0, "Not manual recovery"); - TEST_NEQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE, + TEST_NEQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "Recovery mode"); /* From request, but already failed */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, 4); + vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, 4); sd->recovery_reason = 5; - vb2_check_recovery(&cc); + vb2_check_recovery(&ctx); TEST_EQ(sd->recovery_reason, 5, "Recovery reason already failed"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "NV still cleared"); /* Override */ reset_common_data(); sd->recovery_reason = 6; - cc.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE; - vb2_check_recovery(&cc); + ctx.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE; + vb2_check_recovery(&ctx); TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_MANUAL, "Recovery reason forced"); TEST_NEQ(sd->flags & VB2_SD_FLAG_MANUAL_RECOVERY, @@ -322,9 +322,9 @@ static void recovery_tests(void) /* Override at broken screen */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_RECOVERY_SUBCODE, VB2_RECOVERY_US_TEST); - cc.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE; - vb2_check_recovery(&cc); + vb2_nv_set(&ctx, VB2_NV_RECOVERY_SUBCODE, VB2_RECOVERY_US_TEST); + ctx.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE; + vb2_check_recovery(&ctx); TEST_EQ(sd->recovery_reason, VB2_RECOVERY_US_TEST, "Recovery reason forced from broken"); TEST_NEQ(sd->flags & VB2_SD_FLAG_MANUAL_RECOVERY, @@ -337,107 +337,107 @@ static void dev_switch_tests(void) /* Normal mode */ reset_common_data(); - TEST_SUCC(vb2_check_dev_switch(&cc), "dev mode off"); + TEST_SUCC(vb2_check_dev_switch(&ctx), "dev mode off"); TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd not in dev"); - TEST_EQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx not in dev"); + TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx not in dev"); TEST_EQ(mock_tpm_clear_called, 0, " no tpm clear"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_REQ_WIPEOUT), 0, " no nv wipeout"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_REQ_WIPEOUT), 0, " no nv wipeout"); /* Dev mode */ reset_common_data(); - vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, + vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, (VB2_SECDATA_FLAG_DEV_MODE | VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER)); - TEST_SUCC(vb2_check_dev_switch(&cc), "dev mode on"); + TEST_SUCC(vb2_check_dev_switch(&ctx), "dev mode on"); TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd in dev"); - TEST_NEQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx in dev"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx in dev"); TEST_EQ(mock_tpm_clear_called, 0, " no tpm clear"); /* Any normal mode boot clears dev boot flags */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_DEV_BOOT_USB, 1); - vb2_nv_set(&cc, VB2_NV_DEV_BOOT_LEGACY, 1); - vb2_nv_set(&cc, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1); - vb2_nv_set(&cc, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 1); - vb2_nv_set(&cc, VB2_NV_DEV_DEFAULT_BOOT, 1); - vb2_nv_set(&cc, VB2_NV_FASTBOOT_UNLOCK_IN_FW, 1); - TEST_SUCC(vb2_check_dev_switch(&cc), "dev mode off"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_BOOT_USB), + vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1); + vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1); + vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1); + vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 1); + vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, 1); + vb2_nv_set(&ctx, VB2_NV_FASTBOOT_UNLOCK_IN_FW, 1); + TEST_SUCC(vb2_check_dev_switch(&ctx), "dev mode off"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_USB), 0, " cleared dev boot usb"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_BOOT_LEGACY), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_LEGACY), 0, " cleared dev boot legacy"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_BOOT_SIGNED_ONLY), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY), 0, " cleared dev boot signed only"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP), 0, " cleared dev boot fastboot full cap"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_DEFAULT_BOOT), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_DEFAULT_BOOT), 0, " cleared dev default boot"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FASTBOOT_UNLOCK_IN_FW), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FASTBOOT_UNLOCK_IN_FW), 0, " cleared dev boot fastboot unlock in fw"); /* Normal-dev transition clears TPM */ reset_common_data(); - vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_DEV_MODE); - TEST_SUCC(vb2_check_dev_switch(&cc), "to dev mode"); + vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_DEV_MODE); + TEST_SUCC(vb2_check_dev_switch(&ctx), "to dev mode"); TEST_EQ(mock_tpm_clear_called, 1, " tpm clear"); - vb2_secdata_get(&cc, VB2_SECDATA_FLAGS, &v); + vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v); TEST_EQ(v, (VB2_SECDATA_FLAG_DEV_MODE | VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER), " last boot developer now"); /* Dev-normal transition clears TPM too */ reset_common_data(); - vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, + vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER); - TEST_SUCC(vb2_check_dev_switch(&cc), "from dev mode"); + TEST_SUCC(vb2_check_dev_switch(&ctx), "from dev mode"); TEST_EQ(mock_tpm_clear_called, 1, " tpm clear"); - vb2_secdata_get(&cc, VB2_SECDATA_FLAGS, &v); + vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v); TEST_EQ(v, 0, " last boot not developer now"); /* Disable dev mode */ reset_common_data(); - vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, + vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, (VB2_SECDATA_FLAG_DEV_MODE | VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER)); - vb2_nv_set(&cc, VB2_NV_DISABLE_DEV_REQUEST, 1); - TEST_SUCC(vb2_check_dev_switch(&cc), "disable dev request"); + vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1); + TEST_SUCC(vb2_check_dev_switch(&ctx), "disable dev request"); TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd not in dev"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_DISABLE_DEV_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 0, " request cleared"); /* Force enabled by GBB */ reset_common_data(); sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON; - TEST_SUCC(vb2_check_dev_switch(&cc), "dev on via gbb"); + TEST_SUCC(vb2_check_dev_switch(&ctx), "dev on via gbb"); TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd in dev"); - vb2_secdata_get(&cc, VB2_SECDATA_FLAGS, &v); + vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v); TEST_EQ(v, VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER, " doesn't set dev on in secdata but does set last boot dev"); TEST_EQ(mock_tpm_clear_called, 1, " tpm clear"); /* Request disable by ctx flag */ reset_common_data(); - vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, + vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, (VB2_SECDATA_FLAG_DEV_MODE | VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER)); - cc.flags |= VB2_CONTEXT_DISABLE_DEVELOPER_MODE; - TEST_SUCC(vb2_check_dev_switch(&cc), "disable dev on ctx request"); + ctx.flags |= VB2_CONTEXT_DISABLE_DEVELOPER_MODE; + TEST_SUCC(vb2_check_dev_switch(&ctx), "disable dev on ctx request"); TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd not in dev"); /* Simulate clear owner failure */ reset_common_data(); - vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, + vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER); mock_tpm_clear_retval = VB2_ERROR_EX_TPM_CLEAR_OWNER; - TEST_EQ(vb2_check_dev_switch(&cc), + TEST_EQ(vb2_check_dev_switch(&ctx), VB2_ERROR_EX_TPM_CLEAR_OWNER, "tpm clear fail"); TEST_EQ(mock_tpm_clear_called, 1, " tpm clear"); - vb2_secdata_get(&cc, VB2_SECDATA_FLAGS, &v); + vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v); TEST_EQ(v, VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER, " last boot still developer"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), VB2_RECOVERY_TPM_CLEAR_OWNER, " requests recovery"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_SUBCODE), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE), (uint8_t)VB2_ERROR_EX_TPM_CLEAR_OWNER, " recovery subcode"); /* @@ -445,75 +445,75 @@ static void dev_switch_tests(void) * mode was on in the (inaccessible) secdata. */ reset_common_data(); - vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_DEV_MODE); + vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_DEV_MODE); sd->status &= ~VB2_SD_STATUS_SECDATA_INIT; - TEST_EQ(vb2_check_dev_switch(&cc), VB2_ERROR_SECDATA_GET_UNINITIALIZED, + TEST_EQ(vb2_check_dev_switch(&ctx), VB2_ERROR_SECDATA_GET_UNINITIALIZED, "secdata fail normal"); TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd not in dev"); - TEST_EQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx not in dev"); + TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx not in dev"); /* Secdata failure in recovery mode continues */ reset_common_data(); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; sd->status &= ~VB2_SD_STATUS_SECDATA_INIT; - TEST_SUCC(vb2_check_dev_switch(&cc), "secdata fail recovery"); + TEST_SUCC(vb2_check_dev_switch(&ctx), "secdata fail recovery"); TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd not in dev"); - TEST_EQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx not in dev"); + TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx not in dev"); /* And doesn't check or clear dev disable request */ reset_common_data(); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; sd->status &= ~VB2_SD_STATUS_SECDATA_INIT; - vb2_nv_set(&cc, VB2_NV_DISABLE_DEV_REQUEST, 1); - TEST_SUCC(vb2_check_dev_switch(&cc), "secdata fail recovery disable"); + vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1); + TEST_SUCC(vb2_check_dev_switch(&ctx), "secdata fail recovery disable"); TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd not in dev"); - TEST_EQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx not in dev"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_DISABLE_DEV_REQUEST), + TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx not in dev"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 1, " request not cleared"); /* Can still override with GBB flag */ reset_common_data(); - cc.flags |= VB2_CONTEXT_RECOVERY_MODE; + ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; sd->status &= ~VB2_SD_STATUS_SECDATA_INIT; sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON; - TEST_SUCC(vb2_check_dev_switch(&cc), "secdata fail recovery gbb"); + TEST_SUCC(vb2_check_dev_switch(&ctx), "secdata fail recovery gbb"); TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, " sd in dev"); - TEST_NEQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx in dev"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, " ctx in dev"); TEST_EQ(mock_tpm_clear_called, 1, " tpm clear"); /* Force wipeout by ctx flag */ reset_common_data(); - cc.flags |= VB2_CONTEXT_FORCE_WIPEOUT_MODE; - TEST_SUCC(vb2_check_dev_switch(&cc), "wipeout on ctx flag"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_REQ_WIPEOUT), 1, " nv wipeout"); + ctx.flags |= VB2_CONTEXT_FORCE_WIPEOUT_MODE; + TEST_SUCC(vb2_check_dev_switch(&ctx), "wipeout on ctx flag"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_REQ_WIPEOUT), 1, " nv wipeout"); } static void tpm_clear_tests(void) { /* No clear request */ reset_common_data(); - TEST_SUCC(vb2_check_tpm_clear(&cc), "no clear request"); + TEST_SUCC(vb2_check_tpm_clear(&ctx), "no clear request"); TEST_EQ(mock_tpm_clear_called, 0, "tpm not cleared"); /* Successful request */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1); - TEST_SUCC(vb2_check_tpm_clear(&cc), "clear request"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_CLEAR_TPM_OWNER_REQUEST), + vb2_nv_set(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1); + TEST_SUCC(vb2_check_tpm_clear(&ctx), "clear request"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST), 0, "request cleared"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_CLEAR_TPM_OWNER_DONE), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_CLEAR_TPM_OWNER_DONE), 1, "done set"); TEST_EQ(mock_tpm_clear_called, 1, "tpm cleared"); /* Failed request */ reset_common_data(); mock_tpm_clear_retval = VB2_ERROR_EX_TPM_CLEAR_OWNER; - vb2_nv_set(&cc, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1); - TEST_EQ(vb2_check_tpm_clear(&cc), + vb2_nv_set(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1); + TEST_EQ(vb2_check_tpm_clear(&ctx), VB2_ERROR_EX_TPM_CLEAR_OWNER, "clear failure"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_CLEAR_TPM_OWNER_REQUEST), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST), 0, "request cleared"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_CLEAR_TPM_OWNER_DONE), + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_CLEAR_TPM_OWNER_DONE), 0, "done not set"); } @@ -521,86 +521,86 @@ static void select_slot_tests(void) { /* Slot A */ reset_common_data(); - TEST_SUCC(vb2_select_fw_slot(&cc), "select slot A"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT), + TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot A"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT), VB2_FW_RESULT_UNKNOWN, "result unknown"); TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 0, "tried A"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 0, "tried A"); TEST_EQ(sd->fw_slot, 0, "selected A"); - TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B"); + TEST_EQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B"); /* Slot B */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_TRY_NEXT, 1); - TEST_SUCC(vb2_select_fw_slot(&cc), "select slot B"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT), + vb2_nv_set(&ctx, VB2_NV_TRY_NEXT, 1); + TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot B"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT), VB2_FW_RESULT_UNKNOWN, "result unknown"); TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 1, "tried B"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 1, "tried B"); TEST_EQ(sd->fw_slot, 1, "selected B"); - TEST_NEQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B"); /* Slot A ran out of tries */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING); - TEST_SUCC(vb2_select_fw_slot(&cc), "select slot A out of tries"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_NEXT), 1, "try B next"); + vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING); + TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot A out of tries"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 1, "try B next"); TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 1, "tried B"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 1, "tried B"); TEST_EQ(sd->fw_slot, 1, "selected B"); - TEST_NEQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B"); /* Slot A ran out of tries, even with nofail active */ reset_common_data(); - cc.flags |= VB2_CONTEXT_NOFAIL_BOOT; - vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING); - TEST_SUCC(vb2_select_fw_slot(&cc), "select slot A out of tries"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_NEXT), 1, "try B next"); + ctx.flags |= VB2_CONTEXT_NOFAIL_BOOT; + vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING); + TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot A out of tries"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 1, "try B next"); TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 1, "tried B"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 1, "tried B"); TEST_EQ(sd->fw_slot, 1, "selected B"); - TEST_NEQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B"); + TEST_NEQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B"); /* Slot A used up a try */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_TRY_COUNT, 3); - TEST_SUCC(vb2_select_fw_slot(&cc), "try slot A"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT), + vb2_nv_set(&ctx, VB2_NV_TRY_COUNT, 3); + TEST_SUCC(vb2_select_fw_slot(&ctx), "try slot A"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT), VB2_FW_RESULT_TRYING, "result trying"); TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 0, "tried A"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 0, "tried A"); TEST_EQ(sd->fw_slot, 0, "selected A"); - TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_COUNT), 2, "tries decremented"); + TEST_EQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_COUNT), 2, "tries decremented"); /* Slot A failed, but nofail active */ reset_common_data(); - cc.flags |= VB2_CONTEXT_NOFAIL_BOOT; - vb2_nv_set(&cc, VB2_NV_TRY_COUNT, 3); - TEST_SUCC(vb2_select_fw_slot(&cc), "try slot A"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT), + ctx.flags |= VB2_CONTEXT_NOFAIL_BOOT; + vb2_nv_set(&ctx, VB2_NV_TRY_COUNT, 3); + TEST_SUCC(vb2_select_fw_slot(&ctx), "try slot A"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT), VB2_FW_RESULT_TRYING, "result trying"); TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 0, "tried A"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 0, "tried A"); TEST_EQ(sd->fw_slot, 0, "selected A"); - TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_COUNT), 3, "tries not decremented"); + TEST_EQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_COUNT), 3, "tries not decremented"); /* Tried/result get copied to the previous fields */ reset_common_data(); - vb2_nv_set(&cc, VB2_NV_FW_TRIED, 0); - vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_SUCCESS); - vb2_select_fw_slot(&cc); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_PREV_TRIED), 0, "prev A"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_PREV_RESULT), VB2_FW_RESULT_SUCCESS, + vb2_nv_set(&ctx, VB2_NV_FW_TRIED, 0); + vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_SUCCESS); + vb2_select_fw_slot(&ctx); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_PREV_TRIED), 0, "prev A"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_PREV_RESULT), VB2_FW_RESULT_SUCCESS, "prev success"); reset_common_data(); - vb2_nv_set(&cc, VB2_NV_FW_TRIED, 1); - vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_FAILURE); - vb2_select_fw_slot(&cc); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_PREV_TRIED), 1, "prev B"); - TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_PREV_RESULT), VB2_FW_RESULT_FAILURE, + vb2_nv_set(&ctx, VB2_NV_FW_TRIED, 1); + vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_FAILURE); + vb2_select_fw_slot(&ctx); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_PREV_TRIED), 1, "prev B"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_PREV_RESULT), VB2_FW_RESULT_FAILURE, "prev failure"); } diff --git a/tests/vb2_nvstorage_tests.c b/tests/vb2_nvstorage_tests.c index 52c14d4e..d47eaef7 100644 --- a/tests/vb2_nvstorage_tests.c +++ b/tests/vb2_nvstorage_tests.c @@ -73,12 +73,12 @@ static struct nv_field nv2fields[] = { {0, 0, 0, 0, NULL} }; -static void test_changed(struct vb2_context *ctx, int changed, const char *why) +static void test_changed(struct vb2_context *c, int changed, const char *why) { if (changed) - TEST_NEQ(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED, 0, why); + TEST_NEQ(c->flags & VB2_CONTEXT_NVDATA_CHANGED, 0, why); else - TEST_EQ(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED, 0, why); + TEST_EQ(c->flags & VB2_CONTEXT_NVDATA_CHANGED, 0, why); }; static void nv_storage_test(uint32_t ctxflags) diff --git a/tests/vb2_secdata_tests.c b/tests/vb2_secdata_tests.c index 823efab5..460bf831 100644 --- a/tests/vb2_secdata_tests.c +++ b/tests/vb2_secdata_tests.c @@ -20,14 +20,14 @@ #include "2misc.h" #include "2secdata.h" -static void test_changed(struct vb2_context *ctx, int changed, const char *why) +static void test_changed(struct vb2_context *c, int changed, const char *why) { if (changed) - TEST_NEQ(ctx->flags & VB2_CONTEXT_SECDATA_CHANGED, 0, why); + TEST_NEQ(c->flags & VB2_CONTEXT_SECDATA_CHANGED, 0, why); else - TEST_EQ(ctx->flags & VB2_CONTEXT_SECDATA_CHANGED, 0, why); + TEST_EQ(c->flags & VB2_CONTEXT_SECDATA_CHANGED, 0, why); - ctx->flags &= ~VB2_CONTEXT_SECDATA_CHANGED; + c->flags &= ~VB2_CONTEXT_SECDATA_CHANGED; }; static void secdata_test(void) diff --git a/tests/vb2_secdatak_tests.c b/tests/vb2_secdatak_tests.c index c0207a3a..6a4f9017 100644 --- a/tests/vb2_secdatak_tests.c +++ b/tests/vb2_secdatak_tests.c @@ -21,14 +21,14 @@ #include "2misc.h" #include "2secdata.h" -static void test_changed(struct vb2_context *ctx, int changed, const char *why) +static void test_changed(struct vb2_context *c, int changed, const char *why) { if (changed) - TEST_NEQ(ctx->flags & VB2_CONTEXT_SECDATAK_CHANGED, 0, why); + TEST_NEQ(c->flags & VB2_CONTEXT_SECDATAK_CHANGED, 0, why); else - TEST_EQ(ctx->flags & VB2_CONTEXT_SECDATAK_CHANGED, 0, why); + TEST_EQ(c->flags & VB2_CONTEXT_SECDATAK_CHANGED, 0, why); - ctx->flags &= ~VB2_CONTEXT_SECDATAK_CHANGED; + c->flags &= ~VB2_CONTEXT_SECDATAK_CHANGED; }; static void secdatak_test(void) |