Add TPM2 implementation.
signed off by: jiewen.yao@intel.com reviewed by: guo.dong@intel.com git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@14687 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
jyao1
jyao1
@@ -0,0 +1,700 @@
|
||||
/** @file
|
||||
The library instance provides security service of TPM2 measure boot.
|
||||
|
||||
Caution: This file requires additional review when modified.
|
||||
This library will have external input - PE/COFF image and GPT partition.
|
||||
This external input must be validated carefully to avoid security issue like
|
||||
buffer overflow, integer overflow.
|
||||
|
||||
DxeTpm2MeasureBootLibImageRead() function will make sure the PE/COFF image content
|
||||
read is within the image buffer.
|
||||
|
||||
TrEEMeasurePeImage() function will accept untrusted PE/COFF image and validate its
|
||||
data structure within this image buffer before use.
|
||||
|
||||
TrEEMeasureGptTable() function will receive untrusted GPT partition table, and parse
|
||||
partition data carefully.
|
||||
|
||||
Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
**/
|
||||
|
||||
#include <PiDxe.h>
|
||||
|
||||
#include <Protocol/TrEEProtocol.h>
|
||||
#include <Protocol/BlockIo.h>
|
||||
#include <Protocol/DiskIo.h>
|
||||
#include <Protocol/DevicePathToText.h>
|
||||
#include <Protocol/FirmwareVolumeBlock.h>
|
||||
|
||||
#include <Guid/MeasuredFvHob.h>
|
||||
|
||||
#include <Library/BaseLib.h>
|
||||
#include <Library/DebugLib.h>
|
||||
#include <Library/BaseMemoryLib.h>
|
||||
#include <Library/MemoryAllocationLib.h>
|
||||
#include <Library/DevicePathLib.h>
|
||||
#include <Library/UefiBootServicesTableLib.h>
|
||||
#include <Library/BaseCryptLib.h>
|
||||
#include <Library/PeCoffLib.h>
|
||||
#include <Library/SecurityManagementLib.h>
|
||||
#include <Library/HobLib.h>
|
||||
|
||||
//
|
||||
// Flag to check GPT partition. It only need be measured once.
|
||||
//
|
||||
BOOLEAN mTrEEMeasureGptTableFlag = FALSE;
|
||||
EFI_GUID mTrEEZeroGuid = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}};
|
||||
UINTN mTrEEMeasureGptCount = 0;
|
||||
VOID *mTrEEFileBuffer;
|
||||
UINTN mTrEEImageSize;
|
||||
//
|
||||
// Measured FV handle cache
|
||||
//
|
||||
EFI_HANDLE mTrEECacheMeasuredHandle = NULL;
|
||||
MEASURED_HOB_DATA *mTrEEMeasuredHobData = NULL;
|
||||
|
||||
/**
|
||||
Reads contents of a PE/COFF image in memory buffer.
|
||||
|
||||
Caution: This function may receive untrusted input.
|
||||
PE/COFF image is external input, so this function will make sure the PE/COFF image content
|
||||
read is within the image buffer.
|
||||
|
||||
@param FileHandle Pointer to the file handle to read the PE/COFF image.
|
||||
@param FileOffset Offset into the PE/COFF image to begin the read operation.
|
||||
@param ReadSize On input, the size in bytes of the requested read operation.
|
||||
On output, the number of bytes actually read.
|
||||
@param Buffer Output buffer that contains the data read from the PE/COFF image.
|
||||
|
||||
@retval EFI_SUCCESS The specified portion of the PE/COFF image was read and the size
|
||||
**/
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DxeTpm2MeasureBootLibImageRead (
|
||||
IN VOID *FileHandle,
|
||||
IN UINTN FileOffset,
|
||||
IN OUT UINTN *ReadSize,
|
||||
OUT VOID *Buffer
|
||||
)
|
||||
{
|
||||
UINTN EndPosition;
|
||||
|
||||
if (FileHandle == NULL || ReadSize == NULL || Buffer == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (MAX_ADDRESS - FileOffset < *ReadSize) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
EndPosition = FileOffset + *ReadSize;
|
||||
if (EndPosition > mTrEEImageSize) {
|
||||
*ReadSize = (UINT32)(mTrEEImageSize - FileOffset);
|
||||
}
|
||||
|
||||
if (FileOffset >= mTrEEImageSize) {
|
||||
*ReadSize = 0;
|
||||
}
|
||||
|
||||
CopyMem (Buffer, (UINT8 *)((UINTN) FileHandle + FileOffset), *ReadSize);
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
Measure GPT table data into TPM log.
|
||||
|
||||
Caution: This function may receive untrusted input.
|
||||
The GPT partition table is external input, so this function should parse partition data carefully.
|
||||
|
||||
@param TreeProtocol Pointer to the located TREE protocol instance.
|
||||
@param GptHandle Handle that GPT partition was installed.
|
||||
|
||||
@retval EFI_SUCCESS Successfully measure GPT table.
|
||||
@retval EFI_UNSUPPORTED Not support GPT table on the given handle.
|
||||
@retval EFI_DEVICE_ERROR Can't get GPT table because device error.
|
||||
@retval EFI_OUT_OF_RESOURCES No enough resource to measure GPT table.
|
||||
@retval other error value
|
||||
**/
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
TrEEMeasureGptTable (
|
||||
IN EFI_TREE_PROTOCOL *TreeProtocol,
|
||||
IN EFI_HANDLE GptHandle
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_BLOCK_IO_PROTOCOL *BlockIo;
|
||||
EFI_DISK_IO_PROTOCOL *DiskIo;
|
||||
EFI_PARTITION_TABLE_HEADER *PrimaryHeader;
|
||||
EFI_PARTITION_ENTRY *PartitionEntry;
|
||||
UINT8 *EntryPtr;
|
||||
UINTN NumberOfPartition;
|
||||
UINT32 Index;
|
||||
TrEE_EVENT *TreeEvent;
|
||||
EFI_GPT_DATA *GptData;
|
||||
UINT32 EventSize;
|
||||
|
||||
if (mTrEEMeasureGptCount > 0) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
Status = gBS->HandleProtocol (GptHandle, &gEfiBlockIoProtocolGuid, (VOID**)&BlockIo);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
Status = gBS->HandleProtocol (GptHandle, &gEfiDiskIoProtocolGuid, (VOID**)&DiskIo);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
//
|
||||
// Read the EFI Partition Table Header
|
||||
//
|
||||
PrimaryHeader = (EFI_PARTITION_TABLE_HEADER *) AllocatePool (BlockIo->Media->BlockSize);
|
||||
if (PrimaryHeader == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
Status = DiskIo->ReadDisk (
|
||||
DiskIo,
|
||||
BlockIo->Media->MediaId,
|
||||
1 * BlockIo->Media->BlockSize,
|
||||
BlockIo->Media->BlockSize,
|
||||
(UINT8 *)PrimaryHeader
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((EFI_D_ERROR, "Failed to Read Partition Table Header!\n"));
|
||||
FreePool (PrimaryHeader);
|
||||
return EFI_DEVICE_ERROR;
|
||||
}
|
||||
//
|
||||
// Read the partition entry.
|
||||
//
|
||||
EntryPtr = (UINT8 *)AllocatePool (PrimaryHeader->NumberOfPartitionEntries * PrimaryHeader->SizeOfPartitionEntry);
|
||||
if (EntryPtr == NULL) {
|
||||
FreePool (PrimaryHeader);
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
Status = DiskIo->ReadDisk (
|
||||
DiskIo,
|
||||
BlockIo->Media->MediaId,
|
||||
MultU64x32(PrimaryHeader->PartitionEntryLBA, BlockIo->Media->BlockSize),
|
||||
PrimaryHeader->NumberOfPartitionEntries * PrimaryHeader->SizeOfPartitionEntry,
|
||||
EntryPtr
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
FreePool (PrimaryHeader);
|
||||
FreePool (EntryPtr);
|
||||
return EFI_DEVICE_ERROR;
|
||||
}
|
||||
|
||||
//
|
||||
// Count the valid partition
|
||||
//
|
||||
PartitionEntry = (EFI_PARTITION_ENTRY *)EntryPtr;
|
||||
NumberOfPartition = 0;
|
||||
for (Index = 0; Index < PrimaryHeader->NumberOfPartitionEntries; Index++) {
|
||||
if (!CompareGuid (&PartitionEntry->PartitionTypeGUID, &mTrEEZeroGuid)) {
|
||||
NumberOfPartition++;
|
||||
}
|
||||
PartitionEntry = (EFI_PARTITION_ENTRY *)((UINT8 *)PartitionEntry + PrimaryHeader->SizeOfPartitionEntry);
|
||||
}
|
||||
|
||||
//
|
||||
// Prepare Data for Measurement
|
||||
//
|
||||
EventSize = (UINT32)(sizeof (EFI_GPT_DATA) - sizeof (GptData->Partitions)
|
||||
+ NumberOfPartition * PrimaryHeader->SizeOfPartitionEntry);
|
||||
TreeEvent = (TrEE_EVENT *) AllocateZeroPool (EventSize + sizeof (TrEE_EVENT) - sizeof(TreeEvent->Event));
|
||||
if (TreeEvent == NULL) {
|
||||
FreePool (PrimaryHeader);
|
||||
FreePool (EntryPtr);
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
TreeEvent->Size = EventSize + sizeof (TrEE_EVENT) - sizeof(TreeEvent->Event);
|
||||
TreeEvent->Header.HeaderSize = sizeof(TrEE_EVENT_HEADER);
|
||||
TreeEvent->Header.HeaderVersion = TREE_EVENT_HEADER_VERSION;
|
||||
TreeEvent->Header.PCRIndex = 5;
|
||||
TreeEvent->Header.EventType = EV_EFI_GPT_EVENT;
|
||||
GptData = (EFI_GPT_DATA *) TreeEvent->Event;
|
||||
|
||||
//
|
||||
// Copy the EFI_PARTITION_TABLE_HEADER and NumberOfPartition
|
||||
//
|
||||
CopyMem ((UINT8 *)GptData, (UINT8*)PrimaryHeader, sizeof (EFI_PARTITION_TABLE_HEADER));
|
||||
GptData->NumberOfPartitions = NumberOfPartition;
|
||||
//
|
||||
// Copy the valid partition entry
|
||||
//
|
||||
PartitionEntry = (EFI_PARTITION_ENTRY*)EntryPtr;
|
||||
NumberOfPartition = 0;
|
||||
for (Index = 0; Index < PrimaryHeader->NumberOfPartitionEntries; Index++) {
|
||||
if (!CompareGuid (&PartitionEntry->PartitionTypeGUID, &mTrEEZeroGuid)) {
|
||||
CopyMem (
|
||||
(UINT8 *)&GptData->Partitions + NumberOfPartition * PrimaryHeader->SizeOfPartitionEntry,
|
||||
(UINT8 *)PartitionEntry,
|
||||
PrimaryHeader->SizeOfPartitionEntry
|
||||
);
|
||||
NumberOfPartition++;
|
||||
}
|
||||
PartitionEntry =(EFI_PARTITION_ENTRY *)((UINT8 *)PartitionEntry + PrimaryHeader->SizeOfPartitionEntry);
|
||||
}
|
||||
|
||||
//
|
||||
// Measure the GPT data
|
||||
//
|
||||
Status = TreeProtocol->HashLogExtendEvent (
|
||||
TreeProtocol,
|
||||
0,
|
||||
(EFI_PHYSICAL_ADDRESS) (UINTN) (VOID *) GptData,
|
||||
(UINT64) EventSize,
|
||||
TreeEvent
|
||||
);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
mTrEEMeasureGptCount++;
|
||||
}
|
||||
|
||||
FreePool (PrimaryHeader);
|
||||
FreePool (EntryPtr);
|
||||
FreePool (TreeEvent);
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
Measure PE image into TPM log based on the authenticode image hashing in
|
||||
PE/COFF Specification 8.0 Appendix A.
|
||||
|
||||
Caution: This function may receive untrusted input.
|
||||
PE/COFF image is external input, so this function will validate its data structure
|
||||
within this image buffer before use.
|
||||
|
||||
@param[in] TreeProtocol Pointer to the located TREE protocol instance.
|
||||
@param[in] ImageAddress Start address of image buffer.
|
||||
@param[in] ImageSize Image size
|
||||
@param[in] LinkTimeBase Address that the image is loaded into memory.
|
||||
@param[in] ImageType Image subsystem type.
|
||||
@param[in] FilePath File path is corresponding to the input image.
|
||||
|
||||
@retval EFI_SUCCESS Successfully measure image.
|
||||
@retval EFI_OUT_OF_RESOURCES No enough resource to measure image.
|
||||
@retval EFI_UNSUPPORTED ImageType is unsupported or PE image is mal-format.
|
||||
@retval other error value
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
TrEEMeasurePeImage (
|
||||
IN EFI_TREE_PROTOCOL *TreeProtocol,
|
||||
IN EFI_PHYSICAL_ADDRESS ImageAddress,
|
||||
IN UINTN ImageSize,
|
||||
IN UINTN LinkTimeBase,
|
||||
IN UINT16 ImageType,
|
||||
IN EFI_DEVICE_PATH_PROTOCOL *FilePath
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
TrEE_EVENT *TreeEvent;
|
||||
EFI_IMAGE_LOAD_EVENT *ImageLoad;
|
||||
UINT32 FilePathSize;
|
||||
UINT32 EventSize;
|
||||
|
||||
Status = EFI_UNSUPPORTED;
|
||||
ImageLoad = NULL;
|
||||
FilePathSize = (UINT32) GetDevicePathSize (FilePath);
|
||||
|
||||
//
|
||||
// Determine destination PCR by BootPolicy
|
||||
//
|
||||
EventSize = sizeof (*ImageLoad) - sizeof (ImageLoad->DevicePath) + FilePathSize;
|
||||
TreeEvent = AllocateZeroPool (EventSize + sizeof (TrEE_EVENT) - sizeof(TreeEvent->Event));
|
||||
if (TreeEvent == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
TreeEvent->Size = EventSize + sizeof (TrEE_EVENT) - sizeof(TreeEvent->Event);
|
||||
TreeEvent->Header.HeaderSize = sizeof(TrEE_EVENT_HEADER);
|
||||
TreeEvent->Header.HeaderVersion = TREE_EVENT_HEADER_VERSION;
|
||||
ImageLoad = (EFI_IMAGE_LOAD_EVENT *) TreeEvent->Event;
|
||||
|
||||
switch (ImageType) {
|
||||
case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION:
|
||||
TreeEvent->Header.EventType = EV_EFI_BOOT_SERVICES_APPLICATION;
|
||||
TreeEvent->Header.PCRIndex = 4;
|
||||
break;
|
||||
case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
|
||||
TreeEvent->Header.EventType = EV_EFI_BOOT_SERVICES_DRIVER;
|
||||
TreeEvent->Header.PCRIndex = 2;
|
||||
break;
|
||||
case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
|
||||
TreeEvent->Header.EventType = EV_EFI_RUNTIME_SERVICES_DRIVER;
|
||||
TreeEvent->Header.PCRIndex = 2;
|
||||
break;
|
||||
default:
|
||||
DEBUG ((
|
||||
EFI_D_ERROR,
|
||||
"TrEEMeasurePeImage: Unknown subsystem type %d",
|
||||
ImageType
|
||||
));
|
||||
goto Finish;
|
||||
}
|
||||
|
||||
ImageLoad->ImageLocationInMemory = ImageAddress;
|
||||
ImageLoad->ImageLengthInMemory = ImageSize;
|
||||
ImageLoad->ImageLinkTimeAddress = LinkTimeBase;
|
||||
ImageLoad->LengthOfDevicePath = FilePathSize;
|
||||
CopyMem (ImageLoad->DevicePath, FilePath, FilePathSize);
|
||||
|
||||
//
|
||||
// Log the PE data
|
||||
//
|
||||
Status = TreeProtocol->HashLogExtendEvent (
|
||||
TreeProtocol,
|
||||
PE_COFF_IMAGE,
|
||||
ImageAddress,
|
||||
ImageSize,
|
||||
TreeEvent
|
||||
);
|
||||
if (Status == EFI_VOLUME_FULL) {
|
||||
//
|
||||
// Volume full here means the image is hashed and its result is extended to PCR.
|
||||
// But the event log cann't be saved since log area is full.
|
||||
// Just return EFI_SUCCESS in order not to block the image load.
|
||||
//
|
||||
Status = EFI_SUCCESS;
|
||||
}
|
||||
|
||||
Finish:
|
||||
FreePool (TreeEvent);
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
The security handler is used to abstract platform-specific policy
|
||||
from the DXE core response to an attempt to use a file that returns a
|
||||
given status for the authentication check from the section extraction protocol.
|
||||
|
||||
The possible responses in a given SAP implementation may include locking
|
||||
flash upon failure to authenticate, attestation logging for all signed drivers,
|
||||
and other exception operations. The File parameter allows for possible logging
|
||||
within the SAP of the driver.
|
||||
|
||||
If File is NULL, then EFI_INVALID_PARAMETER is returned.
|
||||
|
||||
If the file specified by File with an authentication status specified by
|
||||
AuthenticationStatus is safe for the DXE Core to use, then EFI_SUCCESS is returned.
|
||||
|
||||
If the file specified by File with an authentication status specified by
|
||||
AuthenticationStatus is not safe for the DXE Core to use under any circumstances,
|
||||
then EFI_ACCESS_DENIED is returned.
|
||||
|
||||
If the file specified by File with an authentication status specified by
|
||||
AuthenticationStatus is not safe for the DXE Core to use right now, but it
|
||||
might be possible to use it at a future time, then EFI_SECURITY_VIOLATION is
|
||||
returned.
|
||||
|
||||
@param[in] AuthenticationStatus This is the authentication status returned
|
||||
from the securitymeasurement services for the
|
||||
input file.
|
||||
@param[in] File This is a pointer to the device path of the file that is
|
||||
being dispatched. This will optionally be used for logging.
|
||||
@param[in] FileBuffer File buffer matches the input file device path.
|
||||
@param[in] FileSize Size of File buffer matches the input file device path.
|
||||
@param[in] BootPolicy A boot policy that was used to call LoadImage() UEFI service.
|
||||
|
||||
@retval EFI_SUCCESS The file specified by DevicePath and non-NULL
|
||||
FileBuffer did authenticate, and the platform policy dictates
|
||||
that the DXE Foundation may use the file.
|
||||
@retval other error value
|
||||
**/
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DxeTpm2MeasureBootHandler (
|
||||
IN UINT32 AuthenticationStatus,
|
||||
IN CONST EFI_DEVICE_PATH_PROTOCOL *File,
|
||||
IN VOID *FileBuffer,
|
||||
IN UINTN FileSize,
|
||||
IN BOOLEAN BootPolicy
|
||||
)
|
||||
{
|
||||
EFI_TREE_PROTOCOL *TreeProtocol;
|
||||
EFI_STATUS Status;
|
||||
TREE_BOOT_SERVICE_CAPABILITY ProtocolCapability;
|
||||
EFI_DEVICE_PATH_PROTOCOL *DevicePathNode;
|
||||
EFI_DEVICE_PATH_PROTOCOL *OrigDevicePathNode;
|
||||
EFI_HANDLE Handle;
|
||||
EFI_HANDLE TempHandle;
|
||||
BOOLEAN ApplicationRequired;
|
||||
PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
|
||||
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol;
|
||||
EFI_PHYSICAL_ADDRESS FvAddress;
|
||||
UINT32 Index;
|
||||
|
||||
Status = gBS->LocateProtocol (&gEfiTrEEProtocolGuid, NULL, (VOID **) &TreeProtocol);
|
||||
if (EFI_ERROR (Status)) {
|
||||
//
|
||||
// TrEE protocol is not installed. So, TPM2 is not present.
|
||||
// Don't do any measurement, and directly return EFI_SUCCESS.
|
||||
//
|
||||
DEBUG ((EFI_D_ERROR, "DxeTpm2MeasureBootHandler - TrEE - %r\n", Status));
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
ProtocolCapability.Size = (UINT8) sizeof (ProtocolCapability);
|
||||
Status = TreeProtocol->GetCapability (
|
||||
TreeProtocol,
|
||||
&ProtocolCapability
|
||||
);
|
||||
if (EFI_ERROR (Status) || !ProtocolCapability.TrEEPresentFlag) {
|
||||
//
|
||||
// TPM device doesn't work or activate.
|
||||
//
|
||||
DEBUG ((EFI_D_ERROR, "DxeTpm2MeasureBootHandler (%r) - TrEEPresentFlag - %x\n", Status, ProtocolCapability.TrEEPresentFlag));
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
//
|
||||
// Copy File Device Path
|
||||
//
|
||||
OrigDevicePathNode = DuplicateDevicePath (File);
|
||||
|
||||
//
|
||||
// 1. Check whether this device path support BlockIo protocol.
|
||||
// Is so, this device path may be a GPT device path.
|
||||
//
|
||||
DevicePathNode = OrigDevicePathNode;
|
||||
Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &DevicePathNode, &Handle);
|
||||
if (!EFI_ERROR (Status) && !mTrEEMeasureGptTableFlag) {
|
||||
//
|
||||
// Find the gpt partion on the given devicepath
|
||||
//
|
||||
DevicePathNode = OrigDevicePathNode;
|
||||
ASSERT (DevicePathNode != NULL);
|
||||
while (!IsDevicePathEnd (DevicePathNode)) {
|
||||
//
|
||||
// Find the Gpt partition
|
||||
//
|
||||
if (DevicePathType (DevicePathNode) == MEDIA_DEVICE_PATH &&
|
||||
DevicePathSubType (DevicePathNode) == MEDIA_HARDDRIVE_DP) {
|
||||
//
|
||||
// Check whether it is a gpt partition or not
|
||||
//
|
||||
if (((HARDDRIVE_DEVICE_PATH *) DevicePathNode)->MBRType == MBR_TYPE_EFI_PARTITION_TABLE_HEADER &&
|
||||
((HARDDRIVE_DEVICE_PATH *) DevicePathNode)->SignatureType == SIGNATURE_TYPE_GUID) {
|
||||
|
||||
//
|
||||
// Change the partition device path to its parent device path (disk) and get the handle.
|
||||
//
|
||||
DevicePathNode->Type = END_DEVICE_PATH_TYPE;
|
||||
DevicePathNode->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
|
||||
DevicePathNode = OrigDevicePathNode;
|
||||
Status = gBS->LocateDevicePath (
|
||||
&gEfiDiskIoProtocolGuid,
|
||||
&DevicePathNode,
|
||||
&Handle
|
||||
);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
//
|
||||
// Measure GPT disk.
|
||||
//
|
||||
Status = TrEEMeasureGptTable (TreeProtocol, Handle);
|
||||
DEBUG ((EFI_D_ERROR, "DxeTpm2MeasureBootHandler - TrEEMeasureGptTable - %r\n", Status));
|
||||
if (!EFI_ERROR (Status)) {
|
||||
//
|
||||
// GPT disk check done.
|
||||
//
|
||||
mTrEEMeasureGptTableFlag = TRUE;
|
||||
}
|
||||
}
|
||||
FreePool (OrigDevicePathNode);
|
||||
OrigDevicePathNode = DuplicateDevicePath (File);
|
||||
ASSERT (OrigDevicePathNode != NULL);
|
||||
break;
|
||||
}
|
||||
}
|
||||
DevicePathNode = NextDevicePathNode (DevicePathNode);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// 2. Measure PE image.
|
||||
//
|
||||
ApplicationRequired = FALSE;
|
||||
|
||||
//
|
||||
// Check whether this device path support FVB protocol.
|
||||
//
|
||||
DevicePathNode = OrigDevicePathNode;
|
||||
Status = gBS->LocateDevicePath (&gEfiFirmwareVolumeBlockProtocolGuid, &DevicePathNode, &Handle);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
//
|
||||
// Don't check FV image, and directly return EFI_SUCCESS.
|
||||
// It can be extended to the specific FV authentication according to the different requirement.
|
||||
//
|
||||
if (IsDevicePathEnd (DevicePathNode)) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
//
|
||||
// The PE image from unmeasured Firmware volume need be measured
|
||||
// The PE image from measured Firmware volume will be mearsured according to policy below.
|
||||
// If it is driver, do not measure
|
||||
// If it is application, still measure.
|
||||
//
|
||||
ApplicationRequired = TRUE;
|
||||
|
||||
if (mTrEECacheMeasuredHandle != Handle && mTrEEMeasuredHobData != NULL) {
|
||||
//
|
||||
// Search for Root FV of this PE image
|
||||
//
|
||||
TempHandle = Handle;
|
||||
do {
|
||||
Status = gBS->HandleProtocol(
|
||||
TempHandle,
|
||||
&gEfiFirmwareVolumeBlockProtocolGuid,
|
||||
(VOID**)&FvbProtocol
|
||||
);
|
||||
TempHandle = FvbProtocol->ParentHandle;
|
||||
} while (!EFI_ERROR(Status) && FvbProtocol->ParentHandle != NULL);
|
||||
|
||||
//
|
||||
// Search in measured FV Hob
|
||||
//
|
||||
Status = FvbProtocol->GetPhysicalAddress(FvbProtocol, &FvAddress);
|
||||
if (EFI_ERROR(Status)){
|
||||
return Status;
|
||||
}
|
||||
|
||||
ApplicationRequired = FALSE;
|
||||
|
||||
for (Index = 0; Index < mTrEEMeasuredHobData->Num; Index++) {
|
||||
if(mTrEEMeasuredHobData->MeasuredFvBuf[Index].BlobBase == FvAddress) {
|
||||
//
|
||||
// Cache measured FV for next measurement
|
||||
//
|
||||
mTrEECacheMeasuredHandle = Handle;
|
||||
ApplicationRequired = TRUE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// File is not found.
|
||||
//
|
||||
if (FileBuffer == NULL) {
|
||||
Status = EFI_SECURITY_VIOLATION;
|
||||
goto Finish;
|
||||
}
|
||||
|
||||
mTrEEImageSize = FileSize;
|
||||
mTrEEFileBuffer = FileBuffer;
|
||||
|
||||
//
|
||||
// Measure PE Image
|
||||
//
|
||||
DevicePathNode = OrigDevicePathNode;
|
||||
ZeroMem (&ImageContext, sizeof (ImageContext));
|
||||
ImageContext.Handle = (VOID *) FileBuffer;
|
||||
ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) DxeTpm2MeasureBootLibImageRead;
|
||||
|
||||
//
|
||||
// Get information about the image being loaded
|
||||
//
|
||||
Status = PeCoffLoaderGetImageInfo (&ImageContext);
|
||||
if (EFI_ERROR (Status)) {
|
||||
//
|
||||
// The information can't be got from the invalid PeImage
|
||||
//
|
||||
goto Finish;
|
||||
}
|
||||
|
||||
//
|
||||
// Measure only application if Application flag is set
|
||||
// Measure drivers and applications if Application flag is not set
|
||||
//
|
||||
if ((!ApplicationRequired) ||
|
||||
(ApplicationRequired && ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION)) {
|
||||
//
|
||||
// Print the image path to be measured.
|
||||
//
|
||||
DEBUG_CODE_BEGIN ();
|
||||
CHAR16 *ToText;
|
||||
ToText = ConvertDevicePathToText (
|
||||
DevicePathNode,
|
||||
FALSE,
|
||||
TRUE
|
||||
);
|
||||
if (ToText != NULL) {
|
||||
DEBUG ((DEBUG_INFO, "The measured image path is %s.\n", ToText));
|
||||
FreePool (ToText);
|
||||
}
|
||||
DEBUG_CODE_END ();
|
||||
|
||||
//
|
||||
// Measure PE image into TPM log.
|
||||
//
|
||||
Status = TrEEMeasurePeImage (
|
||||
TreeProtocol,
|
||||
(EFI_PHYSICAL_ADDRESS) (UINTN) FileBuffer,
|
||||
FileSize,
|
||||
(UINTN) ImageContext.ImageAddress,
|
||||
ImageContext.ImageType,
|
||||
DevicePathNode
|
||||
);
|
||||
DEBUG ((EFI_D_ERROR, "DxeTpm2MeasureBootHandler - TrEEMeasurePeImage - %r\n", Status));
|
||||
}
|
||||
|
||||
//
|
||||
// Done, free the allocated resource.
|
||||
//
|
||||
Finish:
|
||||
if (OrigDevicePathNode != NULL) {
|
||||
FreePool (OrigDevicePathNode);
|
||||
}
|
||||
|
||||
DEBUG ((EFI_D_ERROR, "DxeTpm2MeasureBootHandler - %r\n", Status));
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
Register the security handler to provide TPM measure boot service.
|
||||
|
||||
@param ImageHandle ImageHandle of the loaded driver.
|
||||
@param SystemTable Pointer to the EFI System Table.
|
||||
|
||||
@retval EFI_SUCCESS Register successfully.
|
||||
@retval EFI_OUT_OF_RESOURCES No enough memory to register this handler.
|
||||
**/
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DxeTpm2MeasureBootLibConstructor (
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
)
|
||||
{
|
||||
EFI_HOB_GUID_TYPE *GuidHob;
|
||||
|
||||
GuidHob = NULL;
|
||||
|
||||
GuidHob = GetFirstGuidHob (&gMeasuredFvHobGuid);
|
||||
|
||||
if (GuidHob != NULL) {
|
||||
mTrEEMeasuredHobData = GET_GUID_HOB_DATA (GuidHob);
|
||||
}
|
||||
|
||||
return RegisterSecurity2Handler (
|
||||
DxeTpm2MeasureBootHandler,
|
||||
EFI_AUTH_OPERATION_MEASURE_IMAGE | EFI_AUTH_OPERATION_IMAGE_REQUIRED
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user