mirror of https://github.com/acidanthera/audk.git
479 lines
15 KiB
C
479 lines
15 KiB
C
/** @file
|
|
Var Check PCD handler.
|
|
|
|
Copyright (c) 2015 - 2017, 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 <Library/VarCheckLib.h>
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/DxeServicesLib.h>
|
|
|
|
#include "VarCheckPcdStructure.h"
|
|
|
|
//#define DUMP_VAR_CHECK_PCD
|
|
|
|
GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mVarCheckPcdHex[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
|
|
|
|
/**
|
|
Dump some hexadecimal data.
|
|
|
|
@param[in] Indent How many spaces to indent the output.
|
|
@param[in] Offset The offset of the dump.
|
|
@param[in] DataSize The size in bytes of UserData.
|
|
@param[in] UserData The data to dump.
|
|
|
|
**/
|
|
VOID
|
|
VarCheckPcdInternalDumpHex (
|
|
IN UINTN Indent,
|
|
IN UINTN Offset,
|
|
IN UINTN DataSize,
|
|
IN VOID *UserData
|
|
)
|
|
{
|
|
UINT8 *Data;
|
|
|
|
CHAR8 Val[50];
|
|
|
|
CHAR8 Str[20];
|
|
|
|
UINT8 TempByte;
|
|
UINTN Size;
|
|
UINTN Index;
|
|
|
|
Data = UserData;
|
|
while (DataSize != 0) {
|
|
Size = 16;
|
|
if (Size > DataSize) {
|
|
Size = DataSize;
|
|
}
|
|
|
|
for (Index = 0; Index < Size; Index += 1) {
|
|
TempByte = Data[Index];
|
|
Val[Index * 3 + 0] = mVarCheckPcdHex[TempByte >> 4];
|
|
Val[Index * 3 + 1] = mVarCheckPcdHex[TempByte & 0xF];
|
|
Val[Index * 3 + 2] = (CHAR8) ((Index == 7) ? '-' : ' ');
|
|
Str[Index] = (CHAR8) ((TempByte < ' ' || TempByte > 'z') ? '.' : TempByte);
|
|
}
|
|
|
|
Val[Index * 3] = 0;
|
|
Str[Index] = 0;
|
|
DEBUG ((EFI_D_INFO, "%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str));
|
|
|
|
Data += Size;
|
|
Offset += Size;
|
|
DataSize -= Size;
|
|
}
|
|
}
|
|
|
|
/**
|
|
Var Check Pcd ValidData.
|
|
|
|
@param[in] PcdValidData Pointer to Pcd ValidData
|
|
@param[in] Data Data pointer.
|
|
@param[in] DataSize Size of Data to set.
|
|
|
|
@retval TRUE Check pass
|
|
@retval FALSE Check fail.
|
|
|
|
**/
|
|
BOOLEAN
|
|
VarCheckPcdValidData (
|
|
IN VAR_CHECK_PCD_VALID_DATA_HEADER *PcdValidData,
|
|
IN VOID *Data,
|
|
IN UINTN DataSize
|
|
)
|
|
{
|
|
UINT64 OneData;
|
|
UINT64 Minimum;
|
|
UINT64 Maximum;
|
|
UINT64 OneValue;
|
|
UINT8 *Ptr;
|
|
|
|
OneData = 0;
|
|
CopyMem (&OneData, (UINT8 *) Data + PcdValidData->VarOffset, PcdValidData->StorageWidth);
|
|
|
|
switch (PcdValidData->Type) {
|
|
case VarCheckPcdValidList:
|
|
Ptr = (UINT8 *) ((VAR_CHECK_PCD_VALID_LIST *) PcdValidData + 1);
|
|
while ((UINTN) Ptr < (UINTN) PcdValidData + PcdValidData->Length) {
|
|
OneValue = 0;
|
|
CopyMem (&OneValue, Ptr, PcdValidData->StorageWidth);
|
|
if (OneData == OneValue) {
|
|
//
|
|
// Match
|
|
//
|
|
break;
|
|
}
|
|
Ptr += PcdValidData->StorageWidth;
|
|
}
|
|
if ((UINTN) Ptr >= ((UINTN) PcdValidData + PcdValidData->Length)) {
|
|
//
|
|
// No match
|
|
//
|
|
DEBUG ((EFI_D_INFO, "VarCheckPcdValidData fail: ValidList mismatch (0x%lx)\n", OneData));
|
|
DEBUG_CODE (VarCheckPcdInternalDumpHex (2, 0, PcdValidData->Length, (UINT8 *) PcdValidData););
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case VarCheckPcdValidRange:
|
|
Minimum = 0;
|
|
Maximum = 0;
|
|
Ptr = (UINT8 *) ((VAR_CHECK_PCD_VALID_RANGE *) PcdValidData + 1);
|
|
while ((UINTN) Ptr < (UINTN) PcdValidData + PcdValidData->Length) {
|
|
CopyMem (&Minimum, Ptr, PcdValidData->StorageWidth);
|
|
Ptr += PcdValidData->StorageWidth;
|
|
CopyMem (&Maximum, Ptr, PcdValidData->StorageWidth);
|
|
Ptr += PcdValidData->StorageWidth;
|
|
|
|
if ((OneData >= Minimum) && (OneData <= Maximum)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
DEBUG ((EFI_D_INFO, "VarCheckPcdValidData fail: ValidRange mismatch (0x%lx)\n", OneData));
|
|
DEBUG_CODE (VarCheckPcdInternalDumpHex (2, 0, PcdValidData->Length, (UINT8 *) PcdValidData););
|
|
return FALSE;
|
|
break;
|
|
|
|
default:
|
|
ASSERT (FALSE);
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VAR_CHECK_PCD_VARIABLE_HEADER *mVarCheckPcdBin = NULL;
|
|
UINTN mVarCheckPcdBinSize = 0;
|
|
|
|
/**
|
|
SetVariable check handler PCD.
|
|
|
|
@param[in] VariableName Name of Variable to set.
|
|
@param[in] VendorGuid Variable vendor GUID.
|
|
@param[in] Attributes Attribute value of the variable.
|
|
@param[in] DataSize Size of Data to set.
|
|
@param[in] Data Data pointer.
|
|
|
|
@retval EFI_SUCCESS The SetVariable check result was success.
|
|
@retval EFI_SECURITY_VIOLATION Check fail.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
SetVariableCheckHandlerPcd (
|
|
IN CHAR16 *VariableName,
|
|
IN EFI_GUID *VendorGuid,
|
|
IN UINT32 Attributes,
|
|
IN UINTN DataSize,
|
|
IN VOID *Data
|
|
)
|
|
{
|
|
VAR_CHECK_PCD_VARIABLE_HEADER *PcdVariable;
|
|
VAR_CHECK_PCD_VALID_DATA_HEADER *PcdValidData;
|
|
|
|
if (mVarCheckPcdBin == NULL) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0)) {
|
|
//
|
|
// Do not check delete variable.
|
|
//
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// For Pcd Variable header align.
|
|
//
|
|
PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *) HEADER_ALIGN (mVarCheckPcdBin);
|
|
while ((UINTN) PcdVariable < ((UINTN) mVarCheckPcdBin + mVarCheckPcdBinSize)) {
|
|
if ((StrCmp ((CHAR16 *) (PcdVariable + 1), VariableName) == 0) &&
|
|
(CompareGuid (&PcdVariable->Guid, VendorGuid))) {
|
|
//
|
|
// Found the Pcd Variable that could be used to do check.
|
|
//
|
|
DEBUG ((EFI_D_INFO, "VarCheckPcdVariable - %s:%g with Attributes = 0x%08x Size = 0x%x\n", VariableName, VendorGuid, Attributes, DataSize));
|
|
if ((PcdVariable->Attributes != 0) && PcdVariable->Attributes != Attributes) {
|
|
DEBUG ((EFI_D_INFO, "VarCheckPcdVariable fail for Attributes - 0x%08x\n", PcdVariable->Attributes));
|
|
return EFI_SECURITY_VIOLATION;
|
|
}
|
|
|
|
if (DataSize == 0) {
|
|
DEBUG ((EFI_D_INFO, "VarCheckPcdVariable - CHECK PASS with DataSize == 0 !\n"));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Do the check.
|
|
// For Pcd ValidData header align.
|
|
//
|
|
PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *) HEADER_ALIGN (((UINTN) PcdVariable + PcdVariable->HeaderLength));
|
|
while ((UINTN) PcdValidData < ((UINTN) PcdVariable + PcdVariable->Length)) {
|
|
if (((UINTN) PcdValidData->VarOffset + PcdValidData->StorageWidth) <= DataSize) {
|
|
if (!VarCheckPcdValidData (PcdValidData, Data, DataSize)) {
|
|
return EFI_SECURITY_VIOLATION;
|
|
}
|
|
}
|
|
//
|
|
// For Pcd ValidData header align.
|
|
//
|
|
PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *) HEADER_ALIGN (((UINTN) PcdValidData + PcdValidData->Length));
|
|
}
|
|
|
|
DEBUG ((EFI_D_INFO, "VarCheckPcdVariable - ALL CHECK PASS!\n"));
|
|
return EFI_SUCCESS;
|
|
}
|
|
//
|
|
// For Pcd Variable header align.
|
|
//
|
|
PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *) HEADER_ALIGN (((UINTN) PcdVariable + PcdVariable->Length));
|
|
}
|
|
|
|
// Not found, so pass.
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
#ifdef DUMP_VAR_CHECK_PCD
|
|
/**
|
|
Dump Pcd ValidData.
|
|
|
|
@param[in] PcdValidData Pointer to Pcd ValidData.
|
|
|
|
**/
|
|
VOID
|
|
DumpPcdValidData (
|
|
IN VAR_CHECK_PCD_VALID_DATA_HEADER *PcdValidData
|
|
)
|
|
{
|
|
UINT64 Minimum;
|
|
UINT64 Maximum;
|
|
UINT64 OneValue;
|
|
UINT8 *Ptr;
|
|
|
|
DEBUG ((EFI_D_INFO, " VAR_CHECK_PCD_VALID_DATA_HEADER\n"));
|
|
DEBUG ((EFI_D_INFO, " Type - 0x%02x\n", PcdValidData->Type));
|
|
DEBUG ((EFI_D_INFO, " Length - 0x%02x\n", PcdValidData->Length));
|
|
DEBUG ((EFI_D_INFO, " VarOffset - 0x%04x\n", PcdValidData->VarOffset));
|
|
DEBUG ((EFI_D_INFO, " StorageWidth - 0x%02x\n", PcdValidData->StorageWidth));
|
|
|
|
switch (PcdValidData->Type) {
|
|
case VarCheckPcdValidList:
|
|
Ptr = (UINT8 *) ((VAR_CHECK_PCD_VALID_LIST *) PcdValidData + 1);
|
|
while ((UINTN) Ptr < ((UINTN) PcdValidData + PcdValidData->Length)) {
|
|
OneValue = 0;
|
|
CopyMem (&OneValue, Ptr, PcdValidData->StorageWidth);
|
|
switch (PcdValidData->StorageWidth) {
|
|
case sizeof (UINT8):
|
|
DEBUG ((EFI_D_INFO, " ValidList - 0x%02x\n", OneValue));
|
|
break;
|
|
case sizeof (UINT16):
|
|
DEBUG ((EFI_D_INFO, " ValidList - 0x%04x\n", OneValue));
|
|
break;
|
|
case sizeof (UINT32):
|
|
DEBUG ((EFI_D_INFO, " ValidList - 0x%08x\n", OneValue));
|
|
break;
|
|
case sizeof (UINT64):
|
|
DEBUG ((EFI_D_INFO, " ValidList - 0x%016lx\n", OneValue));
|
|
break;
|
|
default:
|
|
ASSERT (FALSE);
|
|
break;
|
|
}
|
|
Ptr += PcdValidData->StorageWidth;
|
|
}
|
|
break;
|
|
|
|
case VarCheckPcdValidRange:
|
|
Minimum = 0;
|
|
Maximum = 0;
|
|
Ptr = (UINT8 *) ((VAR_CHECK_PCD_VALID_RANGE *) PcdValidData + 1);
|
|
while ((UINTN) Ptr < (UINTN) PcdValidData + PcdValidData->Length) {
|
|
CopyMem (&Minimum, Ptr, PcdValidData->StorageWidth);
|
|
Ptr += PcdValidData->StorageWidth;
|
|
CopyMem (&Maximum, Ptr, PcdValidData->StorageWidth);
|
|
Ptr += PcdValidData->StorageWidth;
|
|
|
|
switch (PcdValidData->StorageWidth) {
|
|
case sizeof (UINT8):
|
|
DEBUG ((EFI_D_INFO, " Minimum - 0x%02x\n", Minimum));
|
|
DEBUG ((EFI_D_INFO, " Maximum - 0x%02x\n", Maximum));
|
|
break;
|
|
case sizeof (UINT16):
|
|
DEBUG ((EFI_D_INFO, " Minimum - 0x%04x\n", Minimum));
|
|
DEBUG ((EFI_D_INFO, " Maximum - 0x%04x\n", Maximum));
|
|
break;
|
|
case sizeof (UINT32):
|
|
DEBUG ((EFI_D_INFO, " Minimum - 0x%08x\n", Minimum));
|
|
DEBUG ((EFI_D_INFO, " Maximum - 0x%08x\n", Maximum));
|
|
break;
|
|
case sizeof (UINT64):
|
|
DEBUG ((EFI_D_INFO, " Minimum - 0x%016lx\n", Minimum));
|
|
DEBUG ((EFI_D_INFO, " Maximum - 0x%016lx\n", Maximum));
|
|
break;
|
|
default:
|
|
ASSERT (FALSE);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ASSERT (FALSE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
Dump Pcd Variable.
|
|
|
|
@param[in] PcdVariable Pointer to Pcd Variable.
|
|
|
|
**/
|
|
VOID
|
|
DumpPcdVariable (
|
|
IN VAR_CHECK_PCD_VARIABLE_HEADER *PcdVariable
|
|
)
|
|
{
|
|
VAR_CHECK_PCD_VALID_DATA_HEADER *PcdValidData;
|
|
|
|
DEBUG ((EFI_D_INFO, "VAR_CHECK_PCD_VARIABLE_HEADER\n"));
|
|
DEBUG ((EFI_D_INFO, " Revision - 0x%04x\n", PcdVariable->Revision));
|
|
DEBUG ((EFI_D_INFO, " HeaderLength - 0x%04x\n", PcdVariable->HeaderLength));
|
|
DEBUG ((EFI_D_INFO, " Length - 0x%08x\n", PcdVariable->Length));
|
|
DEBUG ((EFI_D_INFO, " Type - 0x%02x\n", PcdVariable->Type));
|
|
DEBUG ((EFI_D_INFO, " Attributes - 0x%08x\n", PcdVariable->Attributes));
|
|
DEBUG ((EFI_D_INFO, " Guid - %g\n", &PcdVariable->Guid));
|
|
DEBUG ((EFI_D_INFO, " Name - %s\n", PcdVariable + 1));
|
|
|
|
//
|
|
// For Pcd ValidData header align.
|
|
//
|
|
PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *) HEADER_ALIGN (((UINTN) PcdVariable + PcdVariable->HeaderLength));
|
|
while ((UINTN) PcdValidData < ((UINTN) PcdVariable + PcdVariable->Length)) {
|
|
//
|
|
// Dump Pcd ValidData related to the Pcd Variable.
|
|
//
|
|
DumpPcdValidData (PcdValidData);
|
|
//
|
|
// For Pcd ValidData header align.
|
|
//
|
|
PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *) HEADER_ALIGN (((UINTN) PcdValidData + PcdValidData->Length));
|
|
}
|
|
}
|
|
|
|
/**
|
|
Dump Var Check PCD.
|
|
|
|
@param[in] VarCheckPcdBin Pointer to VarCheckPcdBin.
|
|
@param[in] VarCheckPcdBinSize VarCheckPcdBin size.
|
|
|
|
**/
|
|
VOID
|
|
DumpVarCheckPcd (
|
|
IN VOID *VarCheckPcdBin,
|
|
IN UINTN VarCheckPcdBinSize
|
|
)
|
|
{
|
|
VAR_CHECK_PCD_VARIABLE_HEADER *PcdVariable;
|
|
|
|
DEBUG ((EFI_D_INFO, "DumpVarCheckPcd\n"));
|
|
|
|
//
|
|
// For Pcd Variable header align.
|
|
//
|
|
PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *) HEADER_ALIGN (VarCheckPcdBin);
|
|
while ((UINTN) PcdVariable < ((UINTN) VarCheckPcdBin + VarCheckPcdBinSize)) {
|
|
DumpPcdVariable (PcdVariable);
|
|
//
|
|
// For Pcd Variable header align.
|
|
//
|
|
PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *) HEADER_ALIGN (((UINTN) PcdVariable + PcdVariable->Length));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
Locate VarCheckPcdBin.
|
|
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
LocateVarCheckPcdBin (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
VAR_CHECK_PCD_VARIABLE_HEADER *VarCheckPcdBin;
|
|
UINTN VarCheckPcdBinSize;
|
|
|
|
//
|
|
// Search the VarCheckPcdBin from the first RAW section of current FFS.
|
|
//
|
|
Status = GetSectionFromFfs (
|
|
EFI_SECTION_RAW,
|
|
0,
|
|
(VOID **) &VarCheckPcdBin,
|
|
&VarCheckPcdBinSize
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
//
|
|
// AllocateRuntimeZeroPool () from MemoryAllocateLib is used for runtime access
|
|
// in SetVariable check handler.
|
|
//
|
|
mVarCheckPcdBin = AllocateRuntimeCopyPool (VarCheckPcdBinSize, VarCheckPcdBin);
|
|
ASSERT (mVarCheckPcdBin != NULL);
|
|
//
|
|
// Make sure the allocated buffer for VarCheckPcdBin at required alignment.
|
|
//
|
|
ASSERT ((((UINTN) mVarCheckPcdBin) & (HEADER_ALIGNMENT - 1)) == 0);
|
|
mVarCheckPcdBinSize = VarCheckPcdBinSize;
|
|
FreePool (VarCheckPcdBin);
|
|
|
|
DEBUG ((EFI_D_INFO, "VarCheckPcdBin - at 0x%x size = 0x%x\n", mVarCheckPcdBin, mVarCheckPcdBinSize));
|
|
|
|
#ifdef DUMP_VAR_CHECK_PCD
|
|
DEBUG_CODE (
|
|
DumpVarCheckPcd (mVarCheckPcdBin, mVarCheckPcdBinSize);
|
|
);
|
|
#endif
|
|
} else {
|
|
DEBUG ((EFI_D_INFO, "[VarCheckPcd] No VarCheckPcdBin found at the first RAW section\n"));
|
|
}
|
|
}
|
|
|
|
/**
|
|
Constructor function of VarCheckPcdLib to register var check PCD handler.
|
|
|
|
@param[in] ImageHandle The firmware allocated handle for the EFI image.
|
|
@param[in] SystemTable A pointer to the EFI System Table.
|
|
|
|
@retval EFI_SUCCESS The constructor executed correctly.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
VarCheckPcdLibNullClassConstructor (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
LocateVarCheckPcdBin ();
|
|
VarCheckLibRegisterAddressPointer ((VOID **) &mVarCheckPcdBin);
|
|
VarCheckLibRegisterSetVariableCheckHandler (SetVariableCheckHandlerPcd);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|