eaw/u-boot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge tag 'efi-2021-10-rc5' of https://source.denx.de/u-boot/custodians/u-boot-efi

Browse Source 
Pull request for efi-2021-10-rc5

Documentation:

* add /config bindings to HTML documentation

UEFI

* Fix number_of_algorithms field in TCG EFI Protocol
This commit is contained in:
Tom Rini
2021-09-26 14:15:14 -04:00
parent 8284d6f838 346cee3ac5
commit 76ad024683
4 changed files with 39 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
doc/develop/config_binding.rst Normal file
View File

@@ -0,0 +1,10 @@
.. SPDX-License-Identifier: GPL-2.0+
U-Boot configuration node
=========================
U-Boot supports a number of runtime configuration options which can be selected
in the devicetree.
These are documented in
:download:`The /config node <../../doc/device-tree-bindings/config.txt>`.

1
doc/develop/index.rst
View File

@@ -12,6 +12,7 @@ Implementation
bloblist
ci_testing
commands
config_binding
devicetree/index
driver-model/index
global_data

7
include/efi_tcg2.h
View File

@@ -165,8 +165,6 @@ struct tcg_efi_spec_id_event_algorithm_size {
* @digest_sizes: array of number_of_algorithms pairs
* 1st member defines the algorithm id
* 2nd member defines the algorithm size
* @vendor_info_size: size in bytes for vendor specific info
* @vendor_info: vendor specific info
*/
struct tcg_efi_spec_id_event {
u8 signature[16];
@@ -176,10 +174,7 @@ struct tcg_efi_spec_id_event {
u8 spec_errata;
u8 uintn_size;
u32 number_of_algorithms;
struct tcg_efi_spec_id_event_algorithm_size digest_sizes[TPM2_NUM_PCR_BANKS];
u8 vendor_info_size;
/* U-Boot does not provide any vendor info */
u8 vendor_info[];
struct tcg_efi_spec_id_event_algorithm_size digest_sizes[];
} __packed;
/**

48
lib/efi_loader/efi_tcg2.c
View File

@@ -575,9 +575,10 @@ static efi_status_t tcg2_create_digest(const u8 *input, u32 length,
EFI_PRINT("Unsupported algorithm %x\n", hash_alg);
return EFI_INVALID_PARAMETER;
}
digest_list->digests[digest_list->count].hash_alg = hash_alg;
memcpy(&digest_list->digests[digest_list->count].digest, final,
(u32)alg_to_len(hash_alg));
digest_list->count++;
digest_list->digests[i].hash_alg = hash_alg;
memcpy(&digest_list->digests[i].digest, final, (u32)alg_to_len(hash_alg));
}
return EFI_SUCCESS;
@@ -798,8 +799,9 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
EFI_PRINT("Unsupported algorithm %x\n", hash_alg);
return EFI_INVALID_PARAMETER;
}
digest_list->digests[i].hash_alg = hash_alg;
memcpy(&digest_list->digests[i].digest, hash, (u32)alg_to_len(hash_alg));
digest_list->digests[digest_list->count].hash_alg = hash_alg;
memcpy(&digest_list->digests[digest_list->count].digest, hash,
(u32)alg_to_len(hash_alg));
digest_list->count++;
}
@@ -1120,7 +1122,7 @@ static efi_status_t create_specid_event(struct udevice *dev, void *buffer,
struct tcg_efi_spec_id_event *spec_event;
size_t spec_event_size;
efi_status_t ret = EFI_DEVICE_ERROR;
u32 active = 0, supported = 0;
u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
int err;
size_t i;
@@ -1142,25 +1144,29 @@ static efi_status_t create_specid_event(struct udevice *dev, void *buffer,
TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_ERRATA_TPM2;
spec_event->uintn_size = sizeof(efi_uintn_t) / sizeof(u32);
err = tpm2_get_pcr_info(dev, &supported, &active,
&spec_event->number_of_algorithms);
err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
if (err)
goto out;
for (i = 0; i < pcr_count; i++) {
u16 hash_alg = hash_algo_list[i].hash_alg;
u16 hash_len = hash_algo_list[i].hash_len;
if (active & alg_to_mask(hash_alg)) {
put_unaligned_le16(hash_alg,
&spec_event->digest_sizes[alg_count].algorithm_id);
put_unaligned_le16(hash_len,
&spec_event->digest_sizes[alg_count].digest_size);
alg_count++;
}
}
spec_event->number_of_algorithms = alg_count;
if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
spec_event->number_of_algorithms < 1)
goto out;
for (i = 0; i < spec_event->number_of_algorithms; i++) {
u16 hash_alg = hash_algo_list[i].hash_alg;
u16 hash_len = hash_algo_list[i].hash_len;
if (active && alg_to_mask(hash_alg)) {
put_unaligned_le16(hash_alg,
&spec_event->digest_sizes[i].algorithm_id);
put_unaligned_le16(hash_len,
&spec_event->digest_sizes[i].digest_size);
}
}
/*
* the size of the spec event and placement of vendor_info_size
* depends on supported algoriths
@@ -1169,9 +1175,9 @@ static efi_status_t create_specid_event(struct udevice *dev, void *buffer,
offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
spec_event->number_of_algorithms * sizeof(spec_event->digest_sizes[0]);
/* no vendor info for us */
memset(buffer + spec_event_size, 0,
sizeof(spec_event->vendor_info_size));
spec_event_size += sizeof(spec_event->vendor_info_size);
memset(buffer + spec_event_size, 0, 1);
/* add a byte for vendor_info_size in the spec event */
spec_event_size += 1;
*event_size = spec_event_size;
return EFI_SUCCESS;