static void reset_common_data(enum reset_type t) { struct vb2_keyblock *kb = &mock_vblock.k.kb; struct vb2_fw_preamble *pre = &mock_vblock.p.pre; memset(workbuf, 0xaa, sizeof(workbuf)); memset(&cc, 0, sizeof(cc)); cc.workbuf = workbuf; cc.workbuf_size = sizeof(workbuf); vb2_init_context(&cc); sd = vb2_get_sd(&cc); vb2_nv_init(&cc); vb2_secdata_create(&cc); vb2_secdata_init(&cc); mock_read_res_fail_on_call = 0; mock_unpack_key_retval = VB2_SUCCESS; mock_verify_keyblock_retval = VB2_SUCCESS; mock_verify_preamble_retval = VB2_SUCCESS; /* Set up mock data for verifying keyblock */ sd->fw_version_secdata = 0x20002; vb2_secdata_set(&cc, 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); sd->last_fw_result = VB2_FW_RESULT_SUCCESS; mock_gbb.rootkey.algorithm = 11; mock_gbb.rootkey.key_offset = vb2_offset_of(&mock_gbb.rootkey, &mock_gbb.rootkey_data); mock_gbb.rootkey.key_size = sizeof(mock_gbb.rootkey_data); kb->keyblock_size = sizeof(mock_vblock.k); kb->data_key.algorithm = 7; kb->data_key.key_version = 2; kb->data_key.key_offset = vb2_offset_of(&mock_vblock.k, &mock_vblock.k.data_key_data) - vb2_offset_of(&mock_vblock.k, &kb->data_key); kb->data_key.key_size = sizeof(mock_vblock.k.data_key_data); strcpy(mock_vblock.k.data_key_data, "data key data!!"); pre->preamble_size = sizeof(mock_vblock.p); pre->firmware_version = 2; /* If verifying preamble, verify keyblock first to set up data key */ if (t == FOR_PREAMBLE) vb2_load_fw_keyblock(&cc); };
int vb2_verify_member_inside(const void *parent, size_t parent_size, const void *member, size_t member_size, ptrdiff_t member_data_offset, size_t member_data_size) { const uintptr_t parent_end = (uintptr_t)parent + parent_size; const ptrdiff_t member_offs = vb2_offset_of(parent, member); const ptrdiff_t member_end_offs = member_offs + member_size; const ptrdiff_t data_offs = member_offs + member_data_offset; const ptrdiff_t data_end_offs = data_offs + member_data_size; /* Make sure parent doesn't wrap */ if (parent_end < (uintptr_t)parent) return VB2_ERROR_INSIDE_PARENT_WRAPS; /* * Make sure the member is fully contained in the parent and doesn't * wrap. Use >, not >=, since member_size = 0 is possible. */ if (member_end_offs < member_offs) return VB2_ERROR_INSIDE_MEMBER_WRAPS; if (member_offs < 0 || member_offs > parent_size || member_end_offs > parent_size) return VB2_ERROR_INSIDE_MEMBER_OUTSIDE; /* Make sure the member data is after the member */ if (member_data_size > 0 && data_offs < member_end_offs) return VB2_ERROR_INSIDE_DATA_OVERLAP; /* Make sure parent fully contains member data, if any */ if (data_end_offs < data_offs) return VB2_ERROR_INSIDE_DATA_WRAPS; if (data_offs < 0 || data_offs > parent_size || data_end_offs > parent_size) return VB2_ERROR_INSIDE_DATA_OUTSIDE; return VB2_SUCCESS; }
static void reset_common_data(enum reset_type t) { struct vb2_packed_key *k; memset(workbuf, 0xaa, sizeof(workbuf)); memset(&cc, 0, sizeof(cc)); cc.workbuf = workbuf; cc.workbuf_size = sizeof(workbuf); vb2_workbuf_from_ctx(&cc, &wb); vb2_init_context(&cc); sd = vb2_get_sd(&cc); vb2_nv_init(&cc); vb2_secdatak_create(&cc); vb2_secdatak_init(&cc); vb2_secdatak_set(&cc, VB2_SECDATAK_VERSIONS, 0x20002); mock_read_res_fail_on_call = 0; mock_unpack_key_retval = VB2_SUCCESS; mock_read_gbb_header_retval = VB2_SUCCESS; mock_load_kernel_keyblock_retval = VB2_SUCCESS; mock_load_kernel_preamble_retval = VB2_SUCCESS; /* Recovery key in mock GBB */ mock_gbb.recovery_key.algorithm = 11; mock_gbb.recovery_key.key_offset = vb2_offset_of(&mock_gbb.recovery_key, &mock_gbb.recovery_key_data); mock_gbb.recovery_key.key_size = sizeof(mock_gbb.recovery_key_data); strcpy(mock_gbb.recovery_key_data, "The recovery key"); mock_gbb.h.recovery_key_offset = vb2_offset_of(&mock_gbb, &mock_gbb.recovery_key); mock_gbb.h.recovery_key_size = mock_gbb.recovery_key.key_offset + mock_gbb.recovery_key.key_size; if (t == FOR_PHASE1) { uint8_t *kdata; /* Create mock firmware preamble in the context */ sd->workbuf_preamble_offset = cc.workbuf_used; fwpre = (struct vb2_fw_preamble *) (cc.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)); k->algorithm = 7; 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; cc.workbuf_used += sd->workbuf_preamble_size; } else if (t == FOR_PHASE2) { struct vb2_signature *sig; struct vb2_digest_context dc; uint8_t *sdata; /* Create mock kernel data key */ sd->workbuf_data_key_offset = cc.workbuf_used; kdkey = (struct vb2_packed_key *) (cc.workbuf + sd->workbuf_data_key_offset); kdkey->algorithm = VB2_ALG_RSA2048_SHA256; sd->workbuf_data_key_size = sizeof(*kdkey); cc.workbuf_used += sd->workbuf_data_key_size; /* Create mock kernel preamble in the context */ sd->workbuf_preamble_offset = cc.workbuf_used; kpre = (struct vb2_kernel_preamble *) (cc.workbuf + sd->workbuf_preamble_offset); sdata = (uint8_t *)kpre + sizeof(*kpre); sig = &kpre->body_signature; sig->data_size = sizeof(kernel_data); sig->sig_offset = vb2_offset_of(sig, sdata); sig->sig_size = VB2_SHA512_DIGEST_SIZE; vb2_digest_init(&dc, VB2_HASH_SHA256); vb2_digest_extend(&dc, (const uint8_t *)kernel_data, sizeof(kernel_data)); vb2_digest_finalize(&dc, sdata, sig->sig_size); sd->workbuf_preamble_size = sizeof(*kpre) + sig->sig_size; sd->vblock_preamble_offset = 0x10000 - sd->workbuf_preamble_size; cc.workbuf_used += sd->workbuf_preamble_size; } else { /* Set flags and versions for roll-forward */ sd->kernel_version = 0x20004; sd->kernel_version_secdatak = 0x20002; sd->flags |= VB2_SD_FLAG_KERNEL_SIGNED; cc.flags |= VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD; } };
int vb2api_init_hash2(struct vb2_context *ctx, const struct vb2_guid *guid, uint32_t *size) { struct vb2_shared_data *sd = vb2_get_sd(ctx); const struct vb2_fw_preamble *pre; const struct vb2_signature *sig = NULL; struct vb2_digest_context *dc; struct vb2_workbuf wb; uint32_t hash_offset; int i, rv; vb2_workbuf_from_ctx(ctx, &wb); /* Get preamble pointer */ if (!sd->workbuf_preamble_size) return VB2_ERROR_API_INIT_HASH_PREAMBLE; pre = (const struct vb2_fw_preamble *) (ctx->workbuf + sd->workbuf_preamble_offset); /* Find the matching signature */ hash_offset = pre->hash_offset; for (i = 0; i < pre->hash_count; i++) { sig = (const struct vb2_signature *) ((uint8_t *)pre + hash_offset); if (!memcmp(guid, &sig->guid, sizeof(*guid))) break; hash_offset += sig->c.total_size; } if (i >= pre->hash_count) return VB2_ERROR_API_INIT_HASH_GUID; /* No match */ /* Allocate workbuf space for the hash */ if (sd->workbuf_hash_size) { dc = (struct vb2_digest_context *) (ctx->workbuf + sd->workbuf_hash_offset); } else { uint32_t dig_size = sizeof(*dc); dc = vb2_workbuf_alloc(&wb, dig_size); if (!dc) return VB2_ERROR_API_INIT_HASH_WORKBUF; sd->workbuf_hash_offset = vb2_offset_of(ctx->workbuf, dc); sd->workbuf_hash_size = dig_size; ctx->workbuf_used = sd->workbuf_hash_offset + dig_size; } sd->hash_tag = vb2_offset_of(ctx->workbuf, sig); sd->hash_remaining_size = sig->data_size; if (size) *size = sig->data_size; if (!(pre->flags & VB2_FIRMWARE_PREAMBLE_DISALLOW_HWCRYPTO)) { rv = vb2ex_hwcrypto_digest_init(sig->hash_alg, sig->data_size); if (!rv) { VB2_DEBUG("Using HW crypto engine for hash_alg %d\n", sig->hash_alg); dc->hash_alg = sig->hash_alg; dc->using_hwcrypto = 1; return VB2_SUCCESS; } if (rv != VB2_ERROR_EX_HWCRYPTO_UNSUPPORTED) return rv; VB2_DEBUG("HW crypto for hash_alg %d not supported, using SW\n", sig->hash_alg); } else { VB2_DEBUG("HW crypto forbidden by preamble, using SW\n"); } return vb2_digest_init(dc, sig->hash_alg); }