| /* Copyright 2014 The ChromiumOS Authors |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| * |
| * Externally-callable APIs |
| * (Firmware portion) |
| */ |
| |
| #include "2api.h" |
| #include "2common.h" |
| #include "2misc.h" |
| #include "2nvstorage.h" |
| #include "2rsa.h" |
| #include "2secdata.h" |
| #include "2sha.h" |
| #include "2sysincludes.h" |
| #include "2tpm_bootmode.h" |
| |
| vb2_error_t vb2api_inject_kernel_subkey( |
| struct vb2_context *ctx, |
| const uint8_t *kernel_packed_key_data, |
| uint32_t kernel_packed_key_data_size) |
| { |
| struct vb2_shared_data *sd; |
| enum vb2_boot_mode *boot_mode; |
| struct vb2_workbuf wb; |
| struct vb2_packed_key *kernel_packed_key; |
| uint32_t kernel_packed_key_size; |
| void *dst_packed_key; |
| |
| sd = vb2_get_sd(ctx); |
| vb2_workbuf_from_ctx(ctx, &wb); |
| |
| /* Fully initialize the context and shared data. */ |
| sd->flags = 0; |
| /* Not in recovery. */ |
| sd->recovery_reason = 0; |
| /* FW not used. */ |
| sd->last_fw_slot = VB2_FW_SLOT_A; |
| sd->last_fw_result = VB2_FW_RESULT_UNKNOWN; |
| sd->fw_slot = VB2_FW_SLOT_A; |
| sd->fw_version = 0; |
| sd->fw_version_secdata = 0; |
| /* Clear status field. */ |
| sd->status = 0; |
| /* Invalid offset indicating GBB data is not available. */ |
| sd->gbb_offset = 0; |
| sd->kernel_version = 0; |
| sd->kernel_version_secdata = 0; |
| ctx->flags = 0; |
| boot_mode = (enum vb2_boot_mode *)&ctx->boot_mode; |
| *boot_mode = VB2_BOOT_MODE_NORMAL; |
| |
| /* Make sure passed buffer is big enough for the packed key. */ |
| kernel_packed_key = (struct vb2_packed_key *)kernel_packed_key_data; |
| VB2_TRY(vb2_verify_packed_key_inside(kernel_packed_key_data, |
| kernel_packed_key_data_size, |
| kernel_packed_key)); |
| |
| /* Allocate space in the workbuf in which to copy the key. */ |
| kernel_packed_key_size = |
| kernel_packed_key->key_offset + kernel_packed_key->key_size; |
| dst_packed_key = vb2_workbuf_alloc(&wb, kernel_packed_key_size); |
| if (!dst_packed_key) |
| return VB2_ERROR_WORKBUF_SMALL; |
| |
| /* Copy the packed key data into the workbuf. */ |
| memcpy(dst_packed_key, kernel_packed_key_data, kernel_packed_key_size); |
| |
| /* Set the location of the kernel key data in the context. */ |
| sd->kernel_key_offset = vb2_offset_of(sd, dst_packed_key); |
| sd->kernel_key_size = kernel_packed_key_size; |
| |
| vb2_set_workbuf_used(ctx, |
| sd->kernel_key_offset + kernel_packed_key_size); |
| |
| return VB2_SUCCESS; |
| } |
| |
| vb2_error_t vb2api_fw_phase1(struct vb2_context *ctx) |
| { |
| vb2_error_t rv; |
| struct vb2_shared_data *sd = vb2_get_sd(ctx); |
| |
| /* Initialize NV context */ |
| vb2_nv_init(ctx); |
| |
| /* |
| * Handle caller-requested reboot due to secdata. Do this before we |
| * even look at secdata. If we fail because of a reboot loop we'll be |
| * the first failure so will get to set the recovery reason. |
| */ |
| if (!(ctx->flags & VB2_CONTEXT_SECDATA_WANTS_REBOOT)) { |
| /* No reboot requested */ |
| vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 0); |
| } else if (vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT)) { |
| /* |
| * Reboot requested... again. Fool me once, shame on you. |
| * Fool me twice, shame on me. Fail into recovery to avoid |
| * a reboot loop. |
| */ |
| vb2api_fail(ctx, VB2_RECOVERY_RO_TPM_REBOOT, 0); |
| } else { |
| /* Reboot requested for the first time */ |
| vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1); |
| return VB2_ERROR_API_PHASE1_SECDATA_REBOOT; |
| } |
| |
| /* Initialize firmware & kernel secure data */ |
| rv = vb2_secdata_firmware_init(ctx); |
| if (rv) |
| vb2api_fail(ctx, VB2_RECOVERY_SECDATA_FIRMWARE_INIT, rv); |
| |
| rv = vb2_secdata_kernel_init(ctx); |
| if (rv) |
| vb2api_fail(ctx, VB2_RECOVERY_SECDATA_KERNEL_INIT, rv); |
| |
| /* Load and parse the GBB header */ |
| rv = vb2_fw_init_gbb(ctx); |
| if (rv) |
| vb2api_fail(ctx, VB2_RECOVERY_GBB_HEADER, rv); |
| |
| /* Check for dev switch */ |
| rv = vb2_check_dev_switch(ctx); |
| if (rv) |
| vb2api_fail(ctx, VB2_RECOVERY_DEV_SWITCH, rv); |
| |
| /* |
| * Check for recovery. Note that this function returns void, since any |
| * errors result in requesting recovery. That's also why we don't |
| * return error from failures in the preceding steps; those failures |
| * simply cause us to detect recovery mode here. |
| */ |
| vb2_check_recovery(ctx); |
| |
| /* Decide the boot mode */ |
| vb2_set_boot_mode(ctx); |
| |
| /* |
| * Initialize display if VB2_NV_DISPLAY_REQUEST is set or in non-normal |
| * boot mode. |
| */ |
| if (vb2_nv_get(ctx, VB2_NV_DISPLAY_REQUEST) || |
| ctx->boot_mode != VB2_BOOT_MODE_NORMAL) |
| ctx->flags |= VB2_CONTEXT_DISPLAY_INIT; |
| |
| /* Mark display as available for downstream vboot and vboot callers. */ |
| if (ctx->flags & VB2_CONTEXT_DISPLAY_INIT) |
| sd->flags |= VB2_SD_FLAG_DISPLAY_AVAILABLE; |
| |
| /* Return error if recovery is needed */ |
| if (ctx->flags & VB2_CONTEXT_RECOVERY_MODE) { |
| /* Always clear RAM when entering recovery mode */ |
| ctx->flags |= VB2_CONTEXT_CLEAR_RAM; |
| return VB2_ERROR_API_PHASE1_RECOVERY; |
| } |
| |
| return VB2_SUCCESS; |
| } |
| |
| vb2_error_t vb2api_fw_phase2(struct vb2_context *ctx) |
| { |
| /* |
| * Use the slot from the last boot if this is a resume. Do not set |
| * VB2_SD_STATUS_CHOSE_SLOT so the try counter is not decremented on |
| * failure as we are explicitly not attempting to boot from a new slot. |
| */ |
| if (ctx->flags & VB2_CONTEXT_S3_RESUME) { |
| struct vb2_shared_data *sd = vb2_get_sd(ctx); |
| |
| /* Set the current slot to the last booted slot */ |
| sd->fw_slot = vb2_nv_get(ctx, VB2_NV_FW_TRIED); |
| |
| /* Set context flag if we're using slot B */ |
| if (sd->fw_slot) |
| ctx->flags |= VB2_CONTEXT_FW_SLOT_B; |
| |
| return VB2_SUCCESS; |
| } |
| |
| /* Always clear RAM when entering developer mode */ |
| if (ctx->flags & VB2_CONTEXT_DEVELOPER_MODE) |
| ctx->flags |= VB2_CONTEXT_CLEAR_RAM; |
| |
| /* Check for explicit request to clear TPM */ |
| VB2_TRY(vb2_check_tpm_clear(ctx), ctx, VB2_RECOVERY_TPM_CLEAR_OWNER); |
| |
| /* Decide which firmware slot to try this boot */ |
| VB2_TRY(vb2_select_fw_slot(ctx), ctx, VB2_RECOVERY_FW_SLOT); |
| |
| return VB2_SUCCESS; |
| } |
| |
| vb2_error_t vb2api_extend_hash(struct vb2_context *ctx, |
| const void *buf, |
| uint32_t size) |
| { |
| struct vb2_shared_data *sd = vb2_get_sd(ctx); |
| struct vb2_digest_context *dc = (struct vb2_digest_context *) |
| vb2_member_of(sd, sd->hash_offset); |
| |
| /* Must have initialized hash digest work area */ |
| if (!sd->hash_size) |
| return VB2_ERROR_API_EXTEND_HASH_WORKBUF; |
| |
| /* Don't extend past the data we expect to hash */ |
| if (!size || size > sd->hash_remaining_size) |
| return VB2_ERROR_API_EXTEND_HASH_SIZE; |
| |
| sd->hash_remaining_size -= size; |
| |
| return vb2_digest_extend(dc, buf, size); |
| } |
| |
| vb2_error_t vb2api_get_pcr_digest(struct vb2_context *ctx, |
| enum vb2_pcr_digest which_digest, |
| uint8_t *dest, |
| uint32_t *dest_size) |
| { |
| const uint8_t *digest; |
| uint32_t digest_size; |
| struct vb2_shared_data *sd; |
| |
| switch (which_digest) { |
| case BOOT_MODE_PCR: |
| digest = vb2_get_boot_state_digest(ctx); |
| digest_size = VB2_SHA1_DIGEST_SIZE; |
| break; |
| case HWID_DIGEST_PCR: |
| digest = vb2_get_gbb(ctx)->hwid_digest; |
| digest_size = VB2_GBB_HWID_DIGEST_SIZE; |
| break; |
| case FIRMWARE_VERSION_PCR: |
| sd = vb2_get_sd(ctx); |
| digest = (uint8_t *)&sd->fw_version; |
| digest_size = sizeof(sd->fw_version); |
| break; |
| case KERNEL_VERSION_PCR: |
| sd = vb2_get_sd(ctx); |
| digest = (uint8_t *)&sd->kernel_version; |
| digest_size = sizeof(sd->kernel_version); |
| break; |
| default: |
| return VB2_ERROR_API_PCR_DIGEST; |
| } |
| |
| if (digest == NULL || *dest_size < digest_size) |
| return VB2_ERROR_API_PCR_DIGEST_BUF; |
| |
| memcpy(dest, digest, digest_size); |
| if (digest_size < *dest_size) |
| memset(dest + digest_size, 0, *dest_size - digest_size); |
| |
| *dest_size = digest_size; |
| |
| return VB2_SUCCESS; |
| } |
| |
| vb2_error_t vb2api_fw_phase3(struct vb2_context *ctx) |
| { |
| /* Verify firmware keyblock */ |
| VB2_TRY(vb2_load_fw_keyblock(ctx), ctx, VB2_RECOVERY_RO_INVALID_RW); |
| |
| /* Verify firmware preamble */ |
| VB2_TRY(vb2_load_fw_preamble(ctx), ctx, VB2_RECOVERY_RO_INVALID_RW); |
| |
| return VB2_SUCCESS; |
| } |
| |
| vb2_error_t vb2api_init_hash(struct vb2_context *ctx, uint32_t tag) |
| { |
| struct vb2_shared_data *sd = vb2_get_sd(ctx); |
| const struct vb2_fw_preamble *pre; |
| struct vb2_digest_context *dc; |
| struct vb2_public_key key; |
| struct vb2_workbuf wb; |
| |
| vb2_workbuf_from_ctx(ctx, &wb); |
| |
| if (tag == VB2_HASH_TAG_INVALID) |
| return VB2_ERROR_API_INIT_HASH_TAG; |
| |
| /* Get preamble pointer */ |
| if (!sd->preamble_size) |
| return VB2_ERROR_API_INIT_HASH_PREAMBLE; |
| pre = (const struct vb2_fw_preamble *) |
| vb2_member_of(sd, sd->preamble_offset); |
| |
| /* For now, we only support the firmware body tag */ |
| if (tag != VB2_HASH_TAG_FW_BODY) |
| return VB2_ERROR_API_INIT_HASH_TAG; |
| |
| /* Allocate workbuf space for the hash */ |
| if (sd->hash_size) { |
| dc = (struct vb2_digest_context *) |
| vb2_member_of(sd, sd->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->hash_offset = vb2_offset_of(sd, dc); |
| sd->hash_size = dig_size; |
| vb2_set_workbuf_used(ctx, sd->hash_offset + dig_size); |
| } |
| |
| /* |
| * Work buffer now contains: |
| * - vb2_shared_data |
| * - packed firmware data key |
| * - firmware preamble |
| * - hash data |
| */ |
| |
| /* |
| * Unpack the firmware data key to see which hashing algorithm we |
| * should use. Zero body data size means, that signature contains |
| * metadata hash, so vb2api_get_metadata_hash() should be used instead. |
| */ |
| if (!sd->data_key_size || !pre->body_signature.data_size) |
| return VB2_ERROR_API_INIT_HASH_DATA_KEY; |
| |
| VB2_TRY(vb2_unpack_key_buffer(&key, |
| vb2_member_of(sd, sd->data_key_offset), |
| sd->data_key_size)); |
| |
| sd->hash_tag = tag; |
| sd->hash_remaining_size = pre->body_signature.data_size; |
| |
| return vb2_digest_init(dc, vb2api_hwcrypto_allowed(ctx), |
| key.hash_alg, pre->body_signature.data_size); |
| } |
| |
| vb2_error_t vb2api_check_hash_get_digest(struct vb2_context *ctx, |
| void *digest_out, |
| uint32_t digest_out_size) |
| { |
| struct vb2_shared_data *sd = vb2_get_sd(ctx); |
| struct vb2_digest_context *dc = (struct vb2_digest_context *) |
| vb2_member_of(sd, sd->hash_offset); |
| struct vb2_workbuf wb; |
| |
| uint8_t *digest; |
| uint32_t digest_size = vb2_digest_size(dc->hash_alg); |
| |
| struct vb2_fw_preamble *pre; |
| struct vb2_public_key key; |
| |
| vb2_workbuf_from_ctx(ctx, &wb); |
| |
| /* Get preamble pointer */ |
| if (!sd->preamble_size) |
| return VB2_ERROR_API_CHECK_HASH_PREAMBLE; |
| pre = vb2_member_of(sd, sd->preamble_offset); |
| |
| /* Must have initialized hash digest work area */ |
| if (!sd->hash_size) |
| return VB2_ERROR_API_CHECK_HASH_WORKBUF; |
| |
| /* Should have hashed the right amount of data */ |
| if (sd->hash_remaining_size) |
| return VB2_ERROR_API_CHECK_HASH_SIZE; |
| |
| /* Allocate the digest */ |
| digest = vb2_workbuf_alloc(&wb, digest_size); |
| if (!digest) |
| return VB2_ERROR_API_CHECK_HASH_WORKBUF_DIGEST; |
| |
| /* Finalize the digest */ |
| VB2_TRY(vb2_digest_finalize(dc, digest, digest_size)); |
| |
| /* The code below is specific to the body signature */ |
| if (sd->hash_tag != VB2_HASH_TAG_FW_BODY) |
| return VB2_ERROR_API_CHECK_HASH_TAG; |
| |
| /* |
| * In case of verifying a whole memory region the body signature |
| * is a *signature* of the body data, not just its hash. |
| * So we need to verify the signature. |
| */ |
| |
| /* Unpack the data key */ |
| if (!sd->data_key_size) |
| return VB2_ERROR_API_CHECK_HASH_DATA_KEY; |
| |
| VB2_TRY(vb2_unpack_key_buffer(&key, |
| vb2_member_of(sd, sd->data_key_offset), |
| sd->data_key_size)); |
| |
| key.allow_hwcrypto = vb2api_hwcrypto_allowed(ctx); |
| |
| /* |
| * Check digest vs. signature. Note that this destroys the signature. |
| * That's ok, because we only check each signature once per boot. |
| */ |
| VB2_TRY(vb2_verify_digest(&key, &pre->body_signature, digest, &wb), |
| ctx, VB2_RECOVERY_FW_BODY); |
| |
| if (digest_out != NULL) { |
| if (digest_out_size < digest_size) |
| return VB2_ERROR_API_CHECK_DIGEST_SIZE; |
| memcpy(digest_out, digest, digest_size); |
| } |
| |
| return VB2_SUCCESS; |
| } |
| |
| int vb2api_check_hash(struct vb2_context *ctx) |
| { |
| return vb2api_check_hash_get_digest(ctx, NULL, 0); |
| } |
| |
| union vb2_fw_boot_info vb2api_get_fw_boot_info(struct vb2_context *ctx) |
| { |
| union vb2_fw_boot_info info; |
| |
| struct vb2_shared_data *sd = vb2_get_sd(ctx); |
| |
| info.tries = vb2_nv_get(ctx, VB2_NV_TRY_COUNT); |
| info.slot = sd->fw_slot; |
| info.prev_slot = sd->last_fw_slot; |
| info.prev_result = sd->last_fw_result; |
| info.boot_mode = ctx->boot_mode; |
| |
| VB2_DEBUG("boot_mode=`%s`\n", vb2_boot_mode_string(info.boot_mode)); |
| |
| if (ctx->flags & VB2_CONTEXT_RECOVERY_MODE) { |
| info.recovery_reason = sd->recovery_reason; |
| info.recovery_subcode = vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE); |
| VB2_DEBUG("recovery_reason: %#x / %#x\n", |
| info.recovery_reason, info.recovery_subcode); |
| } |
| |
| VB2_DEBUG("fw_tried=`%s` fw_try_count=%d " |
| "fw_prev_tried=`%s` fw_prev_result=`%s`.\n", |
| vb2_slot_string(info.slot), info.tries, |
| vb2_slot_string(info.prev_slot), |
| vb2_result_string(info.prev_result)); |
| |
| return info; |
| } |
| |
| vb2_error_t vb2api_get_metadata_hash(struct vb2_context *ctx, |
| struct vb2_hash **hash_ptr_out) |
| { |
| struct vb2_shared_data *sd = vb2_get_sd(ctx); |
| struct vb2_workbuf wb; |
| struct vb2_fw_preamble *pre; |
| |
| vb2_workbuf_from_ctx(ctx, &wb); |
| |
| if (!sd->preamble_size) |
| return VB2_ERROR_API_CHECK_HASH_PREAMBLE; |
| pre = vb2_member_of(sd, sd->preamble_offset); |
| |
| /* Zero size of body signature indicates, that signature holds |
| vb2_hash inside. */ |
| if (pre->body_signature.data_size) |
| return VB2_ERROR_API_INIT_HASH_DATA_KEY; |
| |
| struct vb2_hash *hash = |
| (struct vb2_hash *)vb2_signature_data(&pre->body_signature); |
| const uint32_t hsize = vb2_digest_size(hash->algo); |
| if (!hsize || pre->body_signature.sig_size < |
| offsetof(struct vb2_hash, raw) + hsize) |
| return VB2_ERROR_API_CHECK_HASH_SIG_SIZE; |
| |
| *hash_ptr_out = hash; |
| |
| return VB2_SUCCESS; |
| } |