SecurityPkg: Delete Auth Variable driver
authorStar Zeng <star.zeng@intel.com>
Wed, 1 Jul 2015 03:13:02 +0000 (03:13 +0000)
committerlzeng14 <lzeng14@Edk2>
Wed, 1 Jul 2015 03:13:02 +0000 (03:13 +0000)
1. Delete TpmMeasurementLib LibraryClass from SecurityPkg after it moved to MdeModulePkg.
2. Update DxeTpmMeasurementLib.inf to include MdeModulePkg.dec.
3. Delete authenticated variable definition from AuthenticatedVariableFormat.h after
them moved to VariableFormat.h.
4. Replace VARIABLE_HEADER with AUTHENTICATED_VARIABLE_HEADER in EsalVariableDxeSal.
5. Delete VariableInfo from SecurityPkg after it merged to VariableInfo in MdeModulePkg.
6. Delete VariablePei from SecurityPkg after it merged to VariablePei in MdeModulePkg.
7. Delete Auth Variable driver from SecurityPkg after it merged to Variable driver in
MdeModulePkg.
8. Also update PACKAGE_GUID and PACKAGE_VERSION in SecurityPkg.dec after the deletion
of authenticated variable definition, VariableInfo, VariablePei and Auth Variable
driver from SecurityPkg; update PLATFORM_VERSION in SecurityPkg.dsc.

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Star Zeng <star.zeng@intel.com>
Reviewed-by: Jiewen Yao <jiewen.yao@intel.com>
Reviewed-by: Liming Gao <liming.gao@intel.com>
Reviewed-by: Jaben Carsey <jaben.carsey@intel.com>
git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@17772 6f19259b-4bc3-4df7-8a09-765794883524

36 files changed:
SecurityPkg/Application/VariableInfo/VariableInfo.c [deleted file]
SecurityPkg/Application/VariableInfo/VariableInfo.inf [deleted file]
SecurityPkg/Application/VariableInfo/VariableInfo.uni [deleted file]
SecurityPkg/Application/VariableInfo/VariableInfoExtra.uni [deleted file]
SecurityPkg/Include/Guid/AuthenticatedVariableFormat.h
SecurityPkg/Include/Library/TpmMeasurementLib.h [deleted file]
SecurityPkg/Library/DxeTpmMeasurementLib/DxeTpmMeasurementLib.inf
SecurityPkg/SecurityPkg.dec
SecurityPkg/SecurityPkg.dsc
SecurityPkg/VariableAuthenticated/EsalVariableDxeSal/AuthService.c
SecurityPkg/VariableAuthenticated/EsalVariableDxeSal/Variable.c
SecurityPkg/VariableAuthenticated/EsalVariableDxeSal/Variable.h
SecurityPkg/VariableAuthenticated/Pei/PeiVariableAuth.uni [deleted file]
SecurityPkg/VariableAuthenticated/Pei/PeiVariableExtra.uni [deleted file]
SecurityPkg/VariableAuthenticated/Pei/Variable.c [deleted file]
SecurityPkg/VariableAuthenticated/Pei/Variable.h [deleted file]
SecurityPkg/VariableAuthenticated/Pei/VariablePei.inf [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.c [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.h [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/Measurement.c [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/Reclaim.c [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VarCheck.c [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.c [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.h [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableAuthRuntimeDxe.uni [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableAuthSmm.uni [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableAuthSmmRuntimeDxe.uni [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableDxe.c [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableRuntimeDxe.inf [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableRuntimeDxeExtra.uni [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmm.c [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmm.inf [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmExtra.uni [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmRuntimeDxe.c [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmRuntimeDxe.inf [deleted file]
SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmRuntimeDxeExtra.uni [deleted file]

diff --git a/SecurityPkg/Application/VariableInfo/VariableInfo.c b/SecurityPkg/Application/VariableInfo/VariableInfo.c
deleted file mode 100644 (file)
index 0c1ee4b..0000000
+++ /dev/null
@@ -1,265 +0,0 @@
-/** @file\r
-  If the Variable services have PcdVariableCollectStatistics set to TRUE then \r
-  this utility will print out the statistics information. You can use console \r
-  redirection to capture the data.\r
-  \r
-Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials \r
-are licensed and made available under the terms and conditions of the BSD License \r
-which accompanies this distribution.  The full text of the license may be found at \r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#include <Uefi.h>\r
-#include <Library/UefiLib.h>\r
-#include <Library/UefiApplicationEntryPoint.h>\r
-#include <Library/BaseMemoryLib.h>\r
-\r
-#include <Library/BaseLib.h>\r
-#include <Library/MemoryAllocationLib.h>\r
-#include <Library/DebugLib.h>\r
-#include <Library/UefiBootServicesTableLib.h>\r
-\r
-#include <Guid/AuthenticatedVariableFormat.h>\r
-#include <Guid/SmmVariableCommon.h>\r
-#include <Protocol/SmmCommunication.h>\r
-#include <Protocol/SmmVariable.h>\r
-\r
-extern EFI_GUID gEfiVariableGuid;\r
-EFI_SMM_COMMUNICATION_PROTOCOL  *mSmmCommunication = NULL;\r
-\r
-/**\r
-\r
-  This function get the variable statistics data from SMM variable driver. \r
-\r
-  @param[in, out] SmmCommunicateHeader In input, a pointer to a collection of data that will\r
-                                       be passed into an SMM environment. In output, a pointer \r
-                                       to a collection of data that comes from an SMM environment.\r
-  @param[in, out] SmmCommunicateSize   The size of the SmmCommunicateHeader.\r
-                      \r
-  @retval EFI_SUCCESS               Get the statistics data information.\r
-  @retval EFI_NOT_FOUND             Not found.\r
-  @retval EFI_BUFFER_TO_SMALL       DataSize is too small for the result.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-GetVariableStatisticsData (\r
-  IN OUT  EFI_SMM_COMMUNICATE_HEADER  *SmmCommunicateHeader,\r
-  IN OUT  UINTN                       *SmmCommunicateSize\r
-  )\r
-{\r
-  EFI_STATUS                          Status;\r
-  SMM_VARIABLE_COMMUNICATE_HEADER     *SmmVariableFunctionHeader;\r
-\r
-  CopyGuid (&SmmCommunicateHeader->HeaderGuid, &gEfiSmmVariableProtocolGuid);\r
-  SmmCommunicateHeader->MessageLength = *SmmCommunicateSize - OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data);\r
-\r
-  SmmVariableFunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *) &SmmCommunicateHeader->Data[0];\r
-  SmmVariableFunctionHeader->Function = SMM_VARIABLE_FUNCTION_GET_STATISTICS;\r
-  \r
-  Status = mSmmCommunication->Communicate (mSmmCommunication, SmmCommunicateHeader, SmmCommunicateSize);\r
-  ASSERT_EFI_ERROR (Status);\r
-  \r
-  Status = SmmVariableFunctionHeader->ReturnStatus; \r
-  return Status;\r
-}\r
-\r
-\r
-/**\r
-\r
-  This function get and print the variable statistics data from SMM variable driver. \r
-                     \r
-  @retval EFI_SUCCESS               Print the statistics information successfully.\r
-  @retval EFI_NOT_FOUND             Not found the statistics information.\r
-\r
-**/\r
-EFI_STATUS\r
-PrintInfoFromSmm (\r
-  VOID  \r
-  )\r
-{\r
-  EFI_STATUS                                     Status;\r
-  VARIABLE_INFO_ENTRY                            *VariableInfo;\r
-  EFI_SMM_COMMUNICATE_HEADER                     *CommBuffer;\r
-  UINTN                                          RealCommSize;\r
-  UINTN                                          CommSize;\r
-  SMM_VARIABLE_COMMUNICATE_HEADER                *FunctionHeader;\r
-  EFI_SMM_VARIABLE_PROTOCOL                      *Smmvariable;\r
-  \r
-\r
-  Status = gBS->LocateProtocol (&gEfiSmmVariableProtocolGuid, NULL, (VOID **) &Smmvariable);\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  Status = gBS->LocateProtocol (&gEfiSmmCommunicationProtocolGuid, NULL, (VOID **) &mSmmCommunication);\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }  \r
-\r
-  CommSize  = SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE;\r
-  RealCommSize = CommSize;\r
-  CommBuffer = AllocateZeroPool (CommSize);\r
-  ASSERT (CommBuffer != NULL);\r
-  \r
-  Print (L"Non-Volatile SMM Variables:\n");\r
-  do {\r
-    Status = GetVariableStatisticsData (CommBuffer, &CommSize);\r
-    if (Status == EFI_BUFFER_TOO_SMALL) {\r
-      FreePool (CommBuffer);\r
-      CommBuffer = AllocateZeroPool (CommSize);\r
-      ASSERT (CommBuffer != NULL);\r
-      RealCommSize = CommSize;\r
-      Status = GetVariableStatisticsData (CommBuffer, &CommSize);\r
-    }\r
-\r
-    if (EFI_ERROR (Status) || (CommSize <= SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE)) { \r
-      break;\r
-    }\r
-\r
-    if (CommSize < RealCommSize) {\r
-      CommSize = RealCommSize;\r
-    }\r
-\r
-    FunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *) CommBuffer->Data;\r
-    VariableInfo   = (VARIABLE_INFO_ENTRY *) FunctionHeader->Data;\r
-\r
-    if (!VariableInfo->Volatile) {\r
-      Print (\r
-          L"%g R%03d(%03d) W%03d D%03d:%s\n", \r
-          &VariableInfo->VendorGuid,  \r
-          VariableInfo->ReadCount,\r
-          VariableInfo->CacheCount,\r
-          VariableInfo->WriteCount,\r
-          VariableInfo->DeleteCount,\r
-          (CHAR16 *)(VariableInfo + 1)\r
-          );\r
-    }\r
-  } while (TRUE);\r
-  \r
-  Print (L"Volatile SMM Variables:\n");\r
-  ZeroMem (CommBuffer, CommSize);\r
-  do {\r
-    Status = GetVariableStatisticsData (CommBuffer, &CommSize);\r
-    if (Status == EFI_BUFFER_TOO_SMALL) {\r
-      FreePool (CommBuffer);\r
-      CommBuffer = AllocateZeroPool (CommSize);\r
-      ASSERT (CommBuffer != NULL);\r
-      RealCommSize = CommSize;\r
-      Status = GetVariableStatisticsData (CommBuffer, &CommSize);\r
-    }\r
-\r
-    if (EFI_ERROR (Status) || (CommSize <= SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE)) { \r
-      break;\r
-    }\r
-\r
-    if (CommSize < RealCommSize) {\r
-      CommSize = RealCommSize;\r
-    }\r
-\r
-    FunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *) CommBuffer->Data;\r
-    VariableInfo   = (VARIABLE_INFO_ENTRY *) FunctionHeader->Data;\r
-\r
-    if (VariableInfo->Volatile) {\r
-      Print (\r
-          L"%g R%03d(%03d) W%03d D%03d:%s\n", \r
-          &VariableInfo->VendorGuid,  \r
-          VariableInfo->ReadCount,\r
-          VariableInfo->CacheCount,\r
-          VariableInfo->WriteCount,\r
-          VariableInfo->DeleteCount,\r
-          (CHAR16 *)(VariableInfo + 1)\r
-          );\r
-    }\r
-  } while (TRUE);\r
-\r
-  FreePool (CommBuffer);  \r
-  return Status;\r
-}\r
-\r
-/**\r
-  The user Entry Point for Application. The user code starts with this function\r
-  as the real entry point for the image goes into a library that calls this \r
-  function.\r
-\r
-  @param[in] ImageHandle    The firmware allocated handle for the EFI image.  \r
-  @param[in] SystemTable    A pointer to the EFI System Table.\r
-  \r
-  @retval EFI_SUCCESS       The entry point is executed successfully.\r
-  @retval other             Some error occurs when executing this entry point.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-UefiMain (\r
-  IN EFI_HANDLE        ImageHandle,\r
-  IN EFI_SYSTEM_TABLE  *SystemTable\r
-  )\r
-{\r
-  EFI_STATUS            Status;\r
-  VARIABLE_INFO_ENTRY   *VariableInfo;\r
-  VARIABLE_INFO_ENTRY   *Entry;\r
-\r
-  Status = EfiGetSystemConfigurationTable (&gEfiVariableGuid, (VOID **)&Entry);\r
-  if (EFI_ERROR (Status) || (Entry == NULL)) {\r
-    Status = EfiGetSystemConfigurationTable (&gEfiAuthenticatedVariableGuid, (VOID **)&Entry);\r
-  }\r
-\r
-  if (EFI_ERROR (Status) || (Entry == NULL)) {\r
-    Status = PrintInfoFromSmm ();\r
-    if (!EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-  }  \r
-\r
-  if (!EFI_ERROR (Status) && (Entry != NULL)) {\r
-    Print (L"Non-Volatile EFI Variables:\n");\r
-    VariableInfo = Entry;\r
-    do {\r
-      if (!VariableInfo->Volatile) {\r
-        Print (\r
-          L"%g R%03d(%03d) W%03d D%03d:%s\n", \r
-          &VariableInfo->VendorGuid,  \r
-          VariableInfo->ReadCount,\r
-          VariableInfo->CacheCount,\r
-          VariableInfo->WriteCount,\r
-          VariableInfo->DeleteCount,\r
-          VariableInfo->Name\r
-          );\r
-      }\r
-\r
-      VariableInfo = VariableInfo->Next;\r
-    } while (VariableInfo != NULL);\r
-\r
-    Print (L"Volatile EFI Variables:\n");\r
-    VariableInfo = Entry;\r
-    do {\r
-      if (VariableInfo->Volatile) {\r
-        Print (\r
-          L"%g R%03d(%03d) W%03d D%03d:%s\n", \r
-          &VariableInfo->VendorGuid,  \r
-          VariableInfo->ReadCount,\r
-          VariableInfo->CacheCount,\r
-          VariableInfo->WriteCount,\r
-          VariableInfo->DeleteCount,\r
-          VariableInfo->Name\r
-          );\r
-      }\r
-      VariableInfo = VariableInfo->Next;\r
-    } while (VariableInfo != NULL);\r
-\r
-  } else {\r
-    Print (L"Warning: Variable Dxe driver doesn't enable the feature of statistical information!\n");\r
-    Print (L"If you want to see this info, please:\n");\r
-    Print (L"  1. Set PcdVariableCollectStatistics as TRUE\n");\r
-    Print (L"  2. Rebuild Variable Dxe driver\n");\r
-    Print (L"  3. Run \"VariableInfo\" cmd again\n");\r
-  }\r
-\r
-  return Status;\r
-}\r
diff --git a/SecurityPkg/Application/VariableInfo/VariableInfo.inf b/SecurityPkg/Application/VariableInfo/VariableInfo.inf
deleted file mode 100644 (file)
index d4a771a..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-## @file\r
-#  A shell application that displays statistical information about variable usage\r
-#\r
-#  This application can display statistical information about variable usage for SMM variable\r
-#  driver and non-SMM variable driver.\r
-#  Note that if Variable Dxe driver doesn't enable the feature by setting PcdVariableCollectStatistics\r
-#  as TRUE, the application will not display variable statistical information.\r
-#\r
-# Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>\r
-# This program and the accompanying materials\r
-# are licensed and made available under the terms and conditions of the BSD License\r
-# which accompanies this distribution. The full text of the license may be found at\r
-# http://opensource.org/licenses/bsd-license.php\r
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-#\r
-##\r
-\r
-[Defines]\r
-  INF_VERSION                    = 0x00010005\r
-  BASE_NAME                      = VariableInfo\r
-  MODULE_UNI_FILE                = VariableInfo.uni\r
-  FILE_GUID                      = B9EF901F-A2A2-4fc8-8D2B-3A2E07B301CC\r
-  MODULE_TYPE                    = UEFI_APPLICATION\r
-  VERSION_STRING                 = 1.0\r
-  ENTRY_POINT                    = UefiMain\r
-\r
-#\r
-# The following information is for reference only and not required by the build tools.\r
-#\r
-#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC\r
-#\r
-\r
-[Sources]\r
-  VariableInfo.c\r
-\r
-\r
-[Packages]\r
-  MdePkg/MdePkg.dec\r
-  MdeModulePkg/MdeModulePkg.dec\r
-  SecurityPkg/SecurityPkg.dec\r
-\r
-[LibraryClasses]\r
-  UefiApplicationEntryPoint\r
-  UefiLib\r
-  UefiBootServicesTableLib\r
-  BaseMemoryLib\r
-  MemoryAllocationLib\r
-\r
-[Protocols]\r
-  gEfiSmmCommunicationProtocolGuid     ## SOMETIMES_CONSUMES\r
-  \r
-    ## UNDEFINED           # Used to do smm communication\r
-    ## SOMETIMES_CONSUMES \r
-  gEfiSmmVariableProtocolGuid \r
-  \r
-[Guids]\r
-  gEfiAuthenticatedVariableGuid        ## SOMETIMES_CONSUMES    ## SystemTable\r
-  gEfiVariableGuid                     ## CONSUMES              ## SystemTable\r
-\r
-[UserExtensions.TianoCore."ExtraFiles"]\r
-  VariableInfoExtra.uni\r
-  
\ No newline at end of file
diff --git a/SecurityPkg/Application/VariableInfo/VariableInfo.uni b/SecurityPkg/Application/VariableInfo/VariableInfo.uni
deleted file mode 100644 (file)
index e2f214b..0000000
Binary files a/SecurityPkg/Application/VariableInfo/VariableInfo.uni and /dev/null differ
diff --git a/SecurityPkg/Application/VariableInfo/VariableInfoExtra.uni b/SecurityPkg/Application/VariableInfo/VariableInfoExtra.uni
deleted file mode 100644 (file)
index b7fd354..0000000
Binary files a/SecurityPkg/Application/VariableInfo/VariableInfoExtra.uni and /dev/null differ
index c7cd34a943906c048855734f6d8ae304ab7b71c0..1f007cfc73e2ea4c3d545d3a6b92d114e8e1dd31 100644 (file)
@@ -1,16 +1,17 @@
 /** @file\r
-  The variable data structures are related to EDKII-specific \r
+  The variable data structures are related to EDKII-specific\r
   implementation of UEFI authenticated variables.\r
-  AuthenticatedVariableFormat.h defines variable data headers \r
-  and variable storage region headers.\r
-\r
-Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials \r
-are licensed and made available under the terms and conditions of the BSD License \r
-which accompanies this distribution.  The full text of the license may be found at \r
+  AuthenticatedVariableFormat.h defines variable data headers\r
+  and variable storage region headers that has been moved to\r
+  VariableFormat.h.\r
+\r
+Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
 http://opensource.org/licenses/bsd-license.php\r
 \r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
 \r
 **/\r
@@ -18,14 +19,11 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #ifndef __AUTHENTICATED_VARIABLE_FORMAT_H__\r
 #define __AUTHENTICATED_VARIABLE_FORMAT_H__\r
 \r
-#define EFI_AUTHENTICATED_VARIABLE_GUID \\r
-  { 0xaaf32c78, 0x947b, 0x439a, { 0xa1, 0x80, 0x2e, 0x14, 0x4e, 0xc3, 0x77, 0x92 } }\r
+#include <Guid/VariableFormat.h>\r
 \r
 #define EFI_SECURE_BOOT_ENABLE_DISABLE \\r
   { 0xf0a30bc7, 0xaf08, 0x4556, { 0x99, 0xc4, 0x0, 0x10, 0x9, 0xc9, 0x3a, 0x44 } }\r
 \r
-\r
-extern EFI_GUID gEfiAuthenticatedVariableGuid;\r
 extern EFI_GUID gEfiSecureBootEnableDisableGuid;\r
 extern EFI_GUID gEfiCertDbGuid;\r
 extern EFI_GUID gEfiCustomModeEnableGuid;\r
@@ -36,6 +34,10 @@ extern EFI_GUID gEfiVendorKeysNvGuid;
 /// This variable is used for allowing a physically present user to disable\r
 /// Secure Boot via firmware setup without the possession of PKpriv.\r
 ///\r
+/// GUID: gEfiSecureBootEnableDisableGuid\r
+///\r
+/// Format: UINT8\r
+///\r
 #define EFI_SECURE_BOOT_ENABLE_NAME      L"SecureBootEnable"\r
 #define SECURE_BOOT_ENABLE               1\r
 #define SECURE_BOOT_DISABLE              0\r
@@ -48,6 +50,10 @@ extern EFI_GUID gEfiVendorKeysNvGuid;
 ///    Can enroll or delete KEK without existing PK's private key.\r
 ///    Can enroll or delete signature from DB/DBX without KEK's private key.\r
 ///\r
+///  GUID: gEfiCustomModeEnableGuid\r
+///\r
+/// Format: UINT8\r
+///\r
 #define EFI_CUSTOM_MODE_NAME          L"CustomMode"\r
 #define CUSTOM_SECURE_BOOT_MODE       1\r
 #define STANDARD_SECURE_BOOT_MODE     0\r
@@ -58,173 +64,12 @@ extern EFI_GUID gEfiVendorKeysNvGuid;
 ///  the platform vendor has used a mechanism not defined by the UEFI Specification to\r
 ///  transition the system to setup mode or to update secure boot keys.\r
 ///\r
+///  GUID: gEfiVendorKeysNvGuid\r
+///\r
+/// Format: UINT8\r
+///\r
 #define EFI_VENDOR_KEYS_NV_VARIABLE_NAME       L"VendorKeysNv"\r
 #define VENDOR_KEYS_VALID             1\r
 #define VENDOR_KEYS_MODIFIED          0\r
 \r
-///\r
-/// Alignment of variable name and data, according to the architecture:\r
-/// * For IA-32 and Intel(R) 64 architectures: 1.\r
-/// * For IA-64 architecture: 8.\r
-///\r
-#if defined (MDE_CPU_IPF)\r
-#define ALIGNMENT         8\r
-#else\r
-#define ALIGNMENT         1\r
-#endif\r
-\r
-//\r
-// GET_PAD_SIZE calculates the miminal pad bytes needed to make the current pad size satisfy the alignment requirement.\r
-//\r
-#if (ALIGNMENT == 1)\r
-#define GET_PAD_SIZE(a) (0)\r
-#else\r
-#define GET_PAD_SIZE(a) (((~a) + 1) & (ALIGNMENT - 1))\r
-#endif\r
-\r
-///\r
-/// Alignment of Variable Data Header in Variable Store region.\r
-///\r
-#define HEADER_ALIGNMENT  4\r
-#define HEADER_ALIGN(Header)  (((UINTN) (Header) + HEADER_ALIGNMENT - 1) & (~(HEADER_ALIGNMENT - 1)))\r
-\r
-///\r
-/// Status of Variable Store Region.\r
-///\r
-typedef enum {\r
-  EfiRaw,\r
-  EfiValid,\r
-  EfiInvalid,\r
-  EfiUnknown\r
-} VARIABLE_STORE_STATUS;\r
-\r
-#pragma pack(1)\r
-\r
-#define VARIABLE_STORE_SIGNATURE  EFI_AUTHENTICATED_VARIABLE_GUID\r
-\r
-///\r
-/// Variable Store Header Format and State.\r
-///\r
-#define VARIABLE_STORE_FORMATTED          0x5a\r
-#define VARIABLE_STORE_HEALTHY            0xfe\r
-\r
-///\r
-/// Variable Store region header.\r
-///\r
-typedef struct {\r
-  ///\r
-  /// Variable store region signature.\r
-  ///\r
-  EFI_GUID  Signature;\r
-  ///\r
-  /// Size of entire variable store, \r
-  /// including size of variable store header but not including the size of FvHeader.\r
-  ///\r
-  UINT32  Size;\r
-  ///\r
-  /// Variable region format state.\r
-  ///\r
-  UINT8   Format;\r
-  ///\r
-  /// Variable region healthy state.\r
-  ///\r
-  UINT8   State;\r
-  UINT16  Reserved;\r
-  UINT32  Reserved1;\r
-} VARIABLE_STORE_HEADER;\r
-\r
-///\r
-/// Variable data start flag.\r
-///\r
-#define VARIABLE_DATA                     0x55AA\r
-\r
-///\r
-/// Variable State flags.\r
-///\r
-#define VAR_IN_DELETED_TRANSITION     0xfe  ///< Variable is in obsolete transition.\r
-#define VAR_DELETED                   0xfd  ///< Variable is obsolete.\r
-#define VAR_HEADER_VALID_ONLY         0x7f  ///< Variable header has been valid.\r
-#define VAR_ADDED                     0x3f  ///< Variable has been completely added.\r
-\r
-///\r
-/// Variable Attribute combinations.\r
-///\r
-#define VARIABLE_ATTRIBUTE_NV_BS        (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS)\r
-#define VARIABLE_ATTRIBUTE_BS_RT        (EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS)\r
-#define VARIABLE_ATTRIBUTE_AT_AW        (EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS)\r
-#define VARIABLE_ATTRIBUTE_NV_BS_RT     (VARIABLE_ATTRIBUTE_BS_RT | EFI_VARIABLE_NON_VOLATILE)\r
-#define VARIABLE_ATTRIBUTE_NV_BS_RT_HR  (VARIABLE_ATTRIBUTE_NV_BS_RT | EFI_VARIABLE_HARDWARE_ERROR_RECORD)\r
-#define VARIABLE_ATTRIBUTE_NV_BS_RT_AT  (VARIABLE_ATTRIBUTE_NV_BS_RT | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)\r
-#define VARIABLE_ATTRIBUTE_NV_BS_RT_AW  (VARIABLE_ATTRIBUTE_NV_BS_RT | EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS)\r
-#define VARIABLE_ATTRIBUTE_NV_BS_RT_HR_AT_AW    (VARIABLE_ATTRIBUTE_NV_BS_RT_HR | VARIABLE_ATTRIBUTE_AT_AW)\r
-\r
-/// Single Variable Data Header Structure.\r
-///\r
-typedef struct {\r
-  ///\r
-  /// Variable Data Start Flag.\r
-  ///\r
-  UINT16      StartId;\r
-  ///\r
-  /// Variable State defined above.\r
-  ///\r
-  UINT8       State;\r
-  UINT8       Reserved;\r
-  ///\r
-  /// Attributes of variable defined in UEFI specification.\r
-  ///\r
-  UINT32      Attributes;\r
-  ///\r
-  /// Associated monotonic count value against replay attack.\r
-  ///\r
-  UINT64      MonotonicCount;\r
-  ///\r
-  /// Associated TimeStamp value against replay attack. \r
-  ///\r
-  EFI_TIME    TimeStamp;\r
-  ///\r
-  /// Index of associated public key in database.\r
-  ///\r
-  UINT32      PubKeyIndex;\r
-  ///\r
-  /// Size of variable null-terminated Unicode string name.\r
-  ///\r
-  UINT32      NameSize;\r
-  ///\r
-  /// Size of the variable data without this header.\r
-  ///\r
-  UINT32      DataSize;\r
-  ///\r
-  /// A unique identifier for the vendor that produces and consumes this varaible.\r
-  ///\r
-  EFI_GUID    VendorGuid;\r
-} VARIABLE_HEADER;\r
-\r
-typedef struct {\r
-  EFI_GUID    *Guid;\r
-  CHAR16      *Name;\r
-  UINTN       VariableSize;\r
-} VARIABLE_ENTRY_CONSISTENCY;\r
-\r
-#pragma pack()\r
-\r
-typedef struct _VARIABLE_INFO_ENTRY  VARIABLE_INFO_ENTRY;\r
-\r
-///\r
-/// This structure contains the variable list that is put in EFI system table.\r
-/// The variable driver collects all variables that were used at boot service time and produces this list.\r
-/// This is an optional feature to dump all used variables in shell environment. \r
-///\r
-struct _VARIABLE_INFO_ENTRY {\r
-  VARIABLE_INFO_ENTRY *Next;       ///< Pointer to next entry.\r
-  EFI_GUID            VendorGuid;  ///< Guid of Variable.\r
-  CHAR16              *Name;       ///< Name of Variable. \r
-  UINT32              Attributes;  ///< Attributes of variable defined in UEFI spec.\r
-  UINT32              ReadCount;   ///< Number of times to read this variable.\r
-  UINT32              WriteCount;  ///< Number of times to write this variable.\r
-  UINT32              DeleteCount; ///< Number of times to delete this variable.\r
-  UINT32              CacheCount;  ///< Number of times that cache hits this variable.\r
-  BOOLEAN             Volatile;    ///< TRUE if volatile, FALSE if non-volatile.\r
-};\r
-\r
 #endif // __AUTHENTICATED_VARIABLE_FORMAT_H__\r
diff --git a/SecurityPkg/Include/Library/TpmMeasurementLib.h b/SecurityPkg/Include/Library/TpmMeasurementLib.h
deleted file mode 100644 (file)
index 45542f4..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-/** @file\r
-  This library is used by other modules to measure data to TPM.\r
-\r
-Copyright (c) 2012, Intel Corporation. All rights reserved. <BR>\r
-This program and the accompanying materials\r
-are licensed and made available under the terms and conditions of the BSD License\r
-which accompanies this distribution.  The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#ifndef _TPM_MEASUREMENT_LIB_H_\r
-#define _TPM_MEASUREMENT_LIB_H_\r
-\r
-/**\r
-  Tpm measure and log data, and extend the measurement result into a specific PCR.\r
-\r
-  @param[in]  PcrIndex         PCR Index.\r
-  @param[in]  EventType        Event type.\r
-  @param[in]  EventLog         Measurement event log.\r
-  @param[in]  LogLen           Event log length in bytes.\r
-  @param[in]  HashData         The start of the data buffer to be hashed, extended.\r
-  @param[in]  HashDataLen      The length, in bytes, of the buffer referenced by HashData\r
-\r
-  @retval EFI_SUCCESS           Operation completed successfully.\r
-  @retval EFI_UNSUPPORTED       TPM device not available.\r
-  @retval EFI_OUT_OF_RESOURCES  Out of memory.\r
-  @retval EFI_DEVICE_ERROR      The operation was unsuccessful.\r
-**/\r
-EFI_STATUS\r
-EFIAPI \r
-TpmMeasureAndLogData (\r
-  IN UINT32             PcrIndex,\r
-  IN UINT32             EventType,\r
-  IN VOID               *EventLog,\r
-  IN UINT32             LogLen,\r
-  IN VOID               *HashData,\r
-  IN UINT64             HashDataLen\r
-  );\r
-\r
-#endif\r
index d99e48cea8a417248134dff9bb525cc32852370f..4c61d9a21720657268f767389d478f8da9aa6ee9 100644 (file)
@@ -1,10 +1,10 @@
 ## @file\r
 #  Provides TPM measurement functions for TPM1.2 and TPM 2.0\r
 # \r
-#  This library provides TpmMeasureAndLogData() to to measure and log data, and \r
+#  This library provides TpmMeasureAndLogData() to measure and log data, and \r
 #  extend the measurement result into a specific PCR.\r
 #\r
-# Copyright (c) 2012 - 2014, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2012 - 2015, Intel Corporation. All rights reserved.<BR>\r
 # This program and the accompanying materials\r
 # are licensed and made available under the terms and conditions of the BSD License\r
 # which accompanies this distribution. The full text of the license may be found at\r
@@ -34,6 +34,7 @@
 \r
 [Packages]\r
   MdePkg/MdePkg.dec\r
+  MdeModulePkg/MdeModulePkg.dec\r
   SecurityPkg/SecurityPkg.dec\r
 \r
 [LibraryClasses]\r
index 25ec7d0d1c183e81343b8f000c48f97c2149ba30..b0ef20b05b33df2da69cecd54e892a5675bb0c65 100644 (file)
@@ -20,8 +20,8 @@
   DEC_SPECIFICATION              = 0x00010005\r
   PACKAGE_NAME                   = SecurityPkg\r
   PACKAGE_UNI_FILE               = SecurityPkg.uni\r
-  PACKAGE_GUID                   = 24369CAC-6AA6-4fb8-88DB-90BF061668AD\r
-  PACKAGE_VERSION                = 0.94\r
+  PACKAGE_GUID                   = 4EFC4F66-6219-4427-B780-FB99F470767F\r
+  PACKAGE_VERSION                = 0.95\r
 \r
 [Includes]\r
   Include\r
   ##  @libraryclass  Provides TPM Interface Specification (TIS) interfaces for TPM command.\r
   #\r
   TpmCommLib|Include/Library/TpmCommLib.h\r
-    \r
-  ##  @libraryclass  Provides common interfaces about TPM measurement for other modules.\r
-  #\r
-  TpmMeasurementLib|Include/Library/TpmMeasurementLib.h\r
   \r
   ##  @libraryclass  Provides interfaces to handle TPM 2.0 request.\r
   #\r
   # Include/Guid/SecurityPkgTokenSpace.h\r
   gEfiSecurityPkgTokenSpaceGuid      = { 0xd3fb176, 0x9569, 0x4d51, { 0xa3, 0xef, 0x7d, 0x61, 0xc6, 0x4f, 0xea, 0xba }}\r
 \r
-  ## Guid acted as the authenticated variable store header's signature, and to specify the variable list entries put in the EFI system table.\r
-  #  Include/Guid/AuthenticatedVariableFormat.h\r
-  gEfiAuthenticatedVariableGuid      = { 0xaaf32c78, 0x947b, 0x439a, { 0xa1, 0x80, 0x2e, 0x14, 0x4e, 0xc3, 0x77, 0x92 } }\r
-\r
   ## GUID used to "SecureBootEnable" variable for the Secure Boot feature enable/disable.\r
   #  This variable is used for allowing a physically present user to disable Secure Boot via firmware setup without the possession of PKpriv.\r
   #  Include/Guid/AuthenticatedVariableFormat.h\r
index fd74ec18657a87b72c8d9d377cd13509040f6077..fa94d90a2abd28d09e1d153b0015f46802f19cb5 100644 (file)
@@ -15,7 +15,7 @@
 [Defines]\r
   PLATFORM_NAME                  = SecurityPkg\r
   PLATFORM_GUID                  = B2C4614D-AE76-47ba-B876-5988BFED064F\r
-  PLATFORM_VERSION               = 0.94\r
+  PLATFORM_VERSION               = 0.95\r
   DSC_SPECIFICATION              = 0x00010005\r
   OUTPUT_DIRECTORY               = Build/SecurityPkg\r
   SUPPORTED_ARCHITECTURES        = IA32|IPF|X64|EBC\r
   gEfiSecurityPkgTokenSpaceGuid.PcdTpmScrtmPolicy|1\r
 \r
 [Components]\r
-  SecurityPkg/VariableAuthenticated/Pei/VariablePei.inf\r
   SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.inf\r
   #SecurityPkg/Library/DxeDeferImageLoadLib/DxeDeferImageLoadLib.inf\r
   SecurityPkg/Library/DxeImageAuthenticationStatusLib/DxeImageAuthenticationStatusLib.inf\r
   #\r
   # Application\r
   #\r
-  SecurityPkg/Application/VariableInfo/VariableInfo.inf\r
   SecurityPkg/Application/RngTest/RngTest.inf\r
 \r
   #\r
 #  SecurityPkg/UserIdentification/PwdCredentialProviderDxe/PwdCredentialProviderDxe.inf\r
 #  SecurityPkg/UserIdentification/UsbCredentialProviderDxe/UsbCredentialProviderDxe.inf\r
   SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigDxe.inf\r
-  SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableRuntimeDxe.inf\r
 \r
   #\r
   # TPM\r
   SecurityPkg/Pkcs7Verify/Pkcs7VerifyDxe/Pkcs7VerifyDxe.inf\r
 \r
 [Components.IA32, Components.X64]\r
-  SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmm.inf\r
-  SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmRuntimeDxe.inf\r
   SecurityPkg/Tcg/TcgSmm/TcgSmm.inf\r
   SecurityPkg/Tcg/TrEESmm/TrEESmm.inf\r
   #\r
index 45d5cfe3c655769d15ceef081e863f6d4d686185..490a8b34174db39eedb6f0b626de3d97078f825d 100644 (file)
@@ -39,16 +39,16 @@ AutenticatedVariableServiceInitialize (
   VOID\r
   )\r
 {\r
-  EFI_STATUS              Status;\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-  UINT8                   VarValue;\r
-  UINT32                  VarAttr;\r
-  UINTN                   DataSize;\r
-  UINTN                   CtxSize;\r
-  VARIABLE_HEADER         VariableHeader;\r
-  BOOLEAN                 Valid;\r
+  EFI_STATUS                        Status;\r
+  VARIABLE_POINTER_TRACK            Variable;\r
+  UINT8                             VarValue;\r
+  UINT32                            VarAttr;\r
+  UINTN                             DataSize;\r
+  UINTN                             CtxSize;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
+  BOOLEAN                           Valid;\r
 \r
-  ZeroMem (&VariableHeader, sizeof (VARIABLE_HEADER));\r
+  ZeroMem (&VariableHeader, sizeof (AUTHENTICATED_VARIABLE_HEADER));\r
 \r
   mVariableModuleGlobal->AuthenticatedVariableGuid[Physical] = &gEfiAuthenticatedVariableGuid;\r
   mVariableModuleGlobal->CertRsa2048Sha256Guid[Physical]     = &gEfiCertRsa2048Sha256Guid;\r
@@ -477,16 +477,16 @@ ProcessVarWithPk (
   IN  BOOLEAN                   IsPk\r
   )\r
 {\r
-  EFI_STATUS                  Status;\r
-  VARIABLE_POINTER_TRACK      PkVariable;\r
-  EFI_SIGNATURE_LIST          *OldPkList;\r
-  EFI_SIGNATURE_DATA          *OldPkData;\r
-  EFI_VARIABLE_AUTHENTICATION *CertData;\r
-  VARIABLE_HEADER             VariableHeader;\r
-  BOOLEAN                     Valid;\r
+  EFI_STATUS                    Status;\r
+  VARIABLE_POINTER_TRACK        PkVariable;\r
+  EFI_SIGNATURE_LIST            *OldPkList;\r
+  EFI_SIGNATURE_DATA            *OldPkData;\r
+  EFI_VARIABLE_AUTHENTICATION   *CertData;\r
+  AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
+  BOOLEAN                       Valid;\r
 \r
   OldPkList = NULL;\r
-  ZeroMem (&VariableHeader, sizeof (VARIABLE_HEADER));\r
+  ZeroMem (&VariableHeader, sizeof (AUTHENTICATED_VARIABLE_HEADER));\r
 \r
   if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {\r
     //\r
@@ -622,11 +622,11 @@ ProcessVarWithKek (
   EFI_CERT_BLOCK_RSA_2048_SHA256  *CertBlock;\r
   BOOLEAN                         IsFound;\r
   UINT32                          Index;\r
-  VARIABLE_HEADER                 VariableHeader;\r
+  AUTHENTICATED_VARIABLE_HEADER   VariableHeader;\r
   BOOLEAN                         Valid;\r
 \r
   KekList = NULL;\r
-  ZeroMem (&VariableHeader, sizeof (VARIABLE_HEADER));\r
+  ZeroMem (&VariableHeader, sizeof (AUTHENTICATED_VARIABLE_HEADER));\r
 \r
   if (mPlatformMode == USER_MODE) {\r
     if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
@@ -771,7 +771,7 @@ VerifyVariable (
   UINT8                           *PubKey;\r
   EFI_VARIABLE_AUTHENTICATION     *CertData;\r
   EFI_CERT_BLOCK_RSA_2048_SHA256  *CertBlock;\r
-  VARIABLE_HEADER                 VariableHeader;\r
+  AUTHENTICATED_VARIABLE_HEADER   VariableHeader;\r
   BOOLEAN                         Valid;\r
 \r
   CertData    = NULL;\r
@@ -786,7 +786,7 @@ VerifyVariable (
   //\r
   // Determine if first time SetVariable with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS.\r
   //\r
-  ZeroMem (&VariableHeader, sizeof (VARIABLE_HEADER));\r
+  ZeroMem (&VariableHeader, sizeof (AUTHENTICATED_VARIABLE_HEADER));\r
   if (Variable->CurrPtr != 0x0) {\r
     Valid = IsValidVariableHeader (\r
               Variable->CurrPtr, \r
index 0b2775dac89b0df303937ae2b391a041cb3e7593..f08adf038a2e52829c02551fe8f0b62f4590caa5 100644 (file)
@@ -347,7 +347,7 @@ GetVarStoreHeader (
                                  FALSE - Variable is non-volatile.\r
   @param[in]  Global             Pointer to VARAIBLE_GLOBAL structure.\r
   @param[in]  Instance           Instance of FV Block services.\r
-  @param[out] VariableHeader     Pointer to VARIABLE_HEADER for output.\r
+  @param[out] VariableHeader     Pointer to AUTHENTICATED_VARIABLE_HEADER for output.\r
 \r
   @retval TRUE                   Variable header is valid.\r
   @retval FALSE                  Variable header is not valid.\r
@@ -355,15 +355,15 @@ GetVarStoreHeader (
 **/\r
 BOOLEAN\r
 IsValidVariableHeader (\r
-  IN  EFI_PHYSICAL_ADDRESS   VariableAddress,\r
-  IN  BOOLEAN                Volatile,\r
-  IN  VARIABLE_GLOBAL        *Global,\r
-  IN  UINTN                  Instance,\r
-  OUT VARIABLE_HEADER        *VariableHeader  OPTIONAL\r
+  IN  EFI_PHYSICAL_ADDRESS              VariableAddress,\r
+  IN  BOOLEAN                           Volatile,\r
+  IN  VARIABLE_GLOBAL                   *Global,\r
+  IN  UINTN                             Instance,\r
+  OUT AUTHENTICATED_VARIABLE_HEADER     *VariableHeader  OPTIONAL\r
   )\r
 {\r
-  EFI_STATUS            Status;\r
-  VARIABLE_HEADER       LocalVariableHeader;\r
+  EFI_STATUS                            Status;\r
+  AUTHENTICATED_VARIABLE_HEADER         LocalVariableHeader;\r
 \r
   Status = AccessVariableStore (\r
              FALSE,\r
@@ -371,7 +371,7 @@ IsValidVariableHeader (
              Volatile,\r
              Instance,\r
              VariableAddress,\r
-             sizeof (VARIABLE_HEADER),\r
+             sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
              &LocalVariableHeader    \r
              );\r
 \r
@@ -380,7 +380,7 @@ IsValidVariableHeader (
   }\r
 \r
   if (VariableHeader != NULL) {\r
-    CopyMem (VariableHeader, &LocalVariableHeader, sizeof (VARIABLE_HEADER));\r
+    CopyMem (VariableHeader, &LocalVariableHeader, sizeof (AUTHENTICATED_VARIABLE_HEADER));\r
   }\r
 \r
   return TRUE;\r
@@ -439,7 +439,7 @@ GetVariableStoreStatus (
 **/\r
 UINTN\r
 NameSizeOfVariable (\r
-  IN  VARIABLE_HEADER   *Variable\r
+  IN  AUTHENTICATED_VARIABLE_HEADER     *Variable\r
   )\r
 {\r
   if (Variable->State    == (UINT8) (-1) ||\r
@@ -465,7 +465,7 @@ NameSizeOfVariable (
 **/\r
 UINTN\r
 DataSizeOfVariable (\r
-  IN  VARIABLE_HEADER   *Variable\r
+  IN  AUTHENTICATED_VARIABLE_HEADER     *Variable\r
   )\r
 {\r
   if (Variable->State    == (UINT8)  -1 ||\r
@@ -500,10 +500,10 @@ GetVariableNamePtr (
   OUT CHAR16                 *VariableName\r
   )\r
 {\r
-  EFI_STATUS            Status;\r
-  EFI_PHYSICAL_ADDRESS  Address;\r
-  VARIABLE_HEADER       VariableHeader;\r
-  BOOLEAN               IsValid;\r
+  EFI_STATUS                        Status;\r
+  EFI_PHYSICAL_ADDRESS              Address;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
+  BOOLEAN                           IsValid;\r
 \r
   IsValid = IsValidVariableHeader (VariableAddress, Volatile, Global, Instance, &VariableHeader);\r
   ASSERT (IsValid);\r
@@ -511,7 +511,7 @@ GetVariableNamePtr (
   //\r
   // Name area follows variable header.\r
   //\r
-  Address = VariableAddress + sizeof (VARIABLE_HEADER);\r
+  Address = VariableAddress + sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
 \r
   Status = AccessVariableStore (\r
              FALSE,\r
@@ -548,10 +548,10 @@ GetVariableDataPtr (
   OUT CHAR16                 *VariableData\r
   )\r
 {\r
-  EFI_STATUS            Status;\r
-  EFI_PHYSICAL_ADDRESS  Address;\r
-  VARIABLE_HEADER       VariableHeader;\r
-  BOOLEAN               IsValid;\r
+  EFI_STATUS                        Status;\r
+  EFI_PHYSICAL_ADDRESS              Address;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
+  BOOLEAN                           IsValid;\r
 \r
   IsValid = IsValidVariableHeader (VariableAddress, Volatile, Global, Instance, &VariableHeader);\r
   ASSERT (IsValid);\r
@@ -560,7 +560,7 @@ GetVariableDataPtr (
   // Data area follows variable name.\r
   // Be careful about pad size for alignment\r
   //\r
-  Address =  VariableAddress + sizeof (VARIABLE_HEADER);\r
+  Address =  VariableAddress + sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
   Address += NameSizeOfVariable (&VariableHeader);\r
   Address += GET_PAD_SIZE (NameSizeOfVariable (&VariableHeader));\r
 \r
@@ -601,8 +601,8 @@ GetNextVariablePtr (
   IN  UINTN                  Instance\r
   )\r
 {\r
-  EFI_PHYSICAL_ADDRESS  Address;\r
-  VARIABLE_HEADER       VariableHeader;\r
+  EFI_PHYSICAL_ADDRESS              Address;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
 \r
   if (!IsValidVariableHeader (VariableAddress, Volatile, Global, Instance, &VariableHeader)) {\r
     return 0x0;\r
@@ -611,7 +611,7 @@ GetNextVariablePtr (
   //\r
   // Header of next variable follows data area of this variable\r
   //\r
-  Address =  VariableAddress + sizeof (VARIABLE_HEADER);\r
+  Address =  VariableAddress + sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
   Address += NameSizeOfVariable (&VariableHeader);\r
   Address += GET_PAD_SIZE (NameSizeOfVariable (&VariableHeader));\r
   Address += DataSizeOfVariable (&VariableHeader);\r
@@ -964,14 +964,14 @@ FindVariable (
   IN  UINTN                   Instance\r
   )\r
 {\r
-  EFI_PHYSICAL_ADDRESS    Variable[2];\r
-  EFI_PHYSICAL_ADDRESS    InDeletedVariable;\r
-  EFI_PHYSICAL_ADDRESS    VariableStoreHeader[2];\r
-  UINTN                   InDeletedStorageIndex;\r
-  UINTN                   Index;\r
-  CHAR16                  LocalVariableName[MAX_NAME_SIZE];\r
-  BOOLEAN                 Volatile;\r
-  VARIABLE_HEADER         VariableHeader;\r
+  EFI_PHYSICAL_ADDRESS              Variable[2];\r
+  EFI_PHYSICAL_ADDRESS              InDeletedVariable;\r
+  EFI_PHYSICAL_ADDRESS              VariableStoreHeader[2];\r
+  UINTN                             InDeletedStorageIndex;\r
+  UINTN                             Index;\r
+  CHAR16                            LocalVariableName[MAX_NAME_SIZE];\r
+  BOOLEAN                           Volatile;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
 \r
   //\r
   // 0: Volatile, 1: Non-Volatile\r
@@ -1120,24 +1120,24 @@ Reclaim (
   IN  EFI_PHYSICAL_ADDRESS  UpdatingVariable\r
   )\r
 {\r
-  EFI_PHYSICAL_ADDRESS  Variable;\r
-  EFI_PHYSICAL_ADDRESS  AddedVariable;\r
-  EFI_PHYSICAL_ADDRESS  NextVariable;\r
-  EFI_PHYSICAL_ADDRESS  NextAddedVariable;\r
-  VARIABLE_STORE_HEADER VariableStoreHeader;\r
-  VARIABLE_HEADER       VariableHeader;\r
-  VARIABLE_HEADER       AddedVariableHeader;\r
-  CHAR16                VariableName[MAX_NAME_SIZE];\r
-  CHAR16                AddedVariableName[MAX_NAME_SIZE];\r
-  UINT8                 *ValidBuffer;\r
-  UINTN                 MaximumBufferSize;\r
-  UINTN                 VariableSize;\r
-  UINTN                 NameSize;\r
-  UINT8                 *CurrPtr;\r
-  BOOLEAN               FoundAdded;\r
-  EFI_STATUS            Status;\r
-  VARIABLE_GLOBAL       *VariableGlobal;\r
-  UINT32                Instance;\r
+  EFI_PHYSICAL_ADDRESS              Variable;\r
+  EFI_PHYSICAL_ADDRESS              AddedVariable;\r
+  EFI_PHYSICAL_ADDRESS              NextVariable;\r
+  EFI_PHYSICAL_ADDRESS              NextAddedVariable;\r
+  VARIABLE_STORE_HEADER             VariableStoreHeader;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
+  AUTHENTICATED_VARIABLE_HEADER     AddedVariableHeader;\r
+  CHAR16                            VariableName[MAX_NAME_SIZE];\r
+  CHAR16                            AddedVariableName[MAX_NAME_SIZE];\r
+  UINT8                             *ValidBuffer;\r
+  UINTN                             MaximumBufferSize;\r
+  UINTN                             VariableSize;\r
+  UINTN                             NameSize;\r
+  UINT8                             *CurrPtr;\r
+  BOOLEAN                           FoundAdded;\r
+  EFI_STATUS                        Status;\r
+  VARIABLE_GLOBAL                   *VariableGlobal;\r
+  UINT32                            Instance;\r
 \r
   VariableGlobal = &Global->VariableGlobal[VirtualMode];\r
   Instance = Global->FvbInstance;\r
@@ -1200,9 +1200,9 @@ Reclaim (
       VariableSize = NextVariable - Variable;\r
       CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\r
       CurrPtr += VariableSize;\r
-      if ((!IsVolatile) && ((((VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+      if ((!IsVolatile) && ((((AUTHENTICATED_VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
         Global->HwErrVariableTotalSize += VariableSize;\r
-      } else if ((!IsVolatile) && ((((VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+      } else if ((!IsVolatile) && ((((AUTHENTICATED_VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
         Global->CommonVariableTotalSize += VariableSize;\r
       }\r
     }\r
@@ -1254,12 +1254,12 @@ Reclaim (
           // 1. No valid instance of this variable exists.\r
           // 2. It is not the variable that is going to be updated.\r
           //\r
-          ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;\r
+          ((AUTHENTICATED_VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;\r
         }\r
         CurrPtr += VariableSize;\r
-        if ((!IsVolatile) && ((((VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+        if ((!IsVolatile) && ((((AUTHENTICATED_VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
           Global->HwErrVariableTotalSize += VariableSize;\r
-        } else if ((!IsVolatile) && ((((VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+        } else if ((!IsVolatile) && ((((AUTHENTICATED_VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
           Global->CommonVariableTotalSize += VariableSize;\r
         }\r
       }\r
@@ -1729,7 +1729,7 @@ AutoUpdateLangVariable(
                VariableGlobal,\r
                Variable.Volatile,\r
                Instance,\r
-               (UINTN) &(((VARIABLE_HEADER *)Variable.CurrPtr)->DataSize),\r
+               (UINTN) &(((AUTHENTICATED_VARIABLE_HEADER *)Variable.CurrPtr)->DataSize),\r
                sizeof (DataSize),\r
                &DataSize\r
                ); \r
@@ -1865,15 +1865,15 @@ UpdateVariable (
   )\r
 {\r
   EFI_STATUS                          Status;\r
-  VARIABLE_HEADER                     *NextVariable;\r
+  AUTHENTICATED_VARIABLE_HEADER       *NextVariable;\r
   UINTN                               VarNameOffset;\r
   UINTN                               VarDataOffset;\r
   UINTN                               VarNameSize;\r
   UINTN                               VarSize;\r
   BOOLEAN                             Volatile;\r
   UINT8                               State;\r
-  VARIABLE_HEADER                     VariableHeader;\r
-  VARIABLE_HEADER                     *NextVariableHeader;\r
+  AUTHENTICATED_VARIABLE_HEADER       VariableHeader;\r
+  AUTHENTICATED_VARIABLE_HEADER       *NextVariableHeader;\r
   BOOLEAN                             Valid;\r
   BOOLEAN                             Reclaimed;\r
   VARIABLE_STORE_HEADER               VariableStoreHeader;\r
@@ -1930,7 +1930,7 @@ UpdateVariable (
                  VariableGlobal,\r
                  Variable->Volatile,\r
                  Instance,\r
-                 (UINTN) &(((VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
+                 (UINTN) &(((AUTHENTICATED_VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
                  sizeof (UINT8),\r
                  &State\r
                  ); \r
@@ -1946,7 +1946,7 @@ UpdateVariable (
     // then return to the caller immediately.\r
     //\r
     if (DataSizeOfVariable (&VariableHeader) == DataSize) {\r
-      NextVariable = (VARIABLE_HEADER *)GetEndPointer (VariableGlobal->VolatileVariableBase, TRUE, VariableGlobal, Instance);\r
+      NextVariable = (AUTHENTICATED_VARIABLE_HEADER *)GetEndPointer (VariableGlobal->VolatileVariableBase, TRUE, VariableGlobal, Instance);\r
       GetVariableDataPtr (Variable->CurrPtr, Variable->Volatile, VariableGlobal, Instance, (CHAR16 *) NextVariable);\r
       if  (CompareMem (Data, (VOID *) NextVariable, DataSize) == 0) {\r
         UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);\r
@@ -1968,7 +1968,7 @@ UpdateVariable (
                  VariableGlobal,\r
                  Variable->Volatile,\r
                  Instance,\r
-                 (UINTN) &(((VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
+                 (UINTN) &(((AUTHENTICATED_VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
                  sizeof (UINT8),\r
                  &State\r
                  );      \r
@@ -2007,9 +2007,9 @@ UpdateVariable (
   // Tricky part: Use scratch data area at the end of volatile variable store\r
   // as a temporary storage.\r
   //\r
-  NextVariable = (VARIABLE_HEADER *)GetEndPointer (VariableGlobal->VolatileVariableBase, TRUE, VariableGlobal, Instance);\r
+  NextVariable = (AUTHENTICATED_VARIABLE_HEADER *)GetEndPointer (VariableGlobal->VolatileVariableBase, TRUE, VariableGlobal, Instance);\r
   ScratchSize = MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize));\r
-  NextVariableHeader = (VARIABLE_HEADER *) NextVariable;\r
+  NextVariableHeader = (AUTHENTICATED_VARIABLE_HEADER *) NextVariable;\r
 \r
   SetMem (NextVariableHeader, ScratchSize, 0xff);\r
 \r
@@ -2018,7 +2018,7 @@ UpdateVariable (
   NextVariableHeader->PubKeyIndex     = KeyIndex;\r
   NextVariableHeader->MonotonicCount  = MonotonicCount;\r
   NextVariableHeader->Reserved        = 0;\r
-  VarNameOffset                       = sizeof (VARIABLE_HEADER);\r
+  VarNameOffset                       = sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
   VarNameSize                         = StrSize (VariableName);\r
   CopyMem (\r
     (UINT8 *) ((UINTN)NextVariable + VarNameOffset),\r
@@ -2096,7 +2096,7 @@ UpdateVariable (
                FALSE,\r
                Instance,\r
                VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset,\r
-               sizeof (VARIABLE_HEADER),\r
+               sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
                (UINT8 *) NextVariable\r
                );\r
 \r
@@ -2114,7 +2114,7 @@ UpdateVariable (
                FALSE,\r
                Instance,\r
                VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset,\r
-               sizeof (VARIABLE_HEADER),\r
+               sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
                (UINT8 *) NextVariable\r
                );\r
 \r
@@ -2129,9 +2129,9 @@ UpdateVariable (
                VariableGlobal,\r
                FALSE,\r
                Instance,\r
-               VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset + sizeof (VARIABLE_HEADER),\r
-               (UINT32) VarSize - sizeof (VARIABLE_HEADER),\r
-               (UINT8 *) NextVariable + sizeof (VARIABLE_HEADER)\r
+               VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset + sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
+               (UINT32) VarSize - sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
+               (UINT8 *) NextVariable + sizeof (AUTHENTICATED_VARIABLE_HEADER)\r
                );\r
 \r
     if (EFI_ERROR (Status)) {\r
@@ -2147,7 +2147,7 @@ UpdateVariable (
                FALSE,\r
                Instance,\r
                VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset,\r
-               sizeof (VARIABLE_HEADER),\r
+               sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
                (UINT8 *) NextVariable\r
                );\r
 \r
@@ -2212,7 +2212,7 @@ UpdateVariable (
   // has already been eliminated, so no need to delete it.\r
   //\r
   if (!Reclaimed && !EFI_ERROR (Status) && Variable->CurrPtr != 0) {\r
-    State = ((VARIABLE_HEADER *)Variable->CurrPtr)->State;\r
+    State = ((AUTHENTICATED_VARIABLE_HEADER *)Variable->CurrPtr)->State;\r
     State &= VAR_DELETED;\r
 \r
     Status = AccessVariableStore (\r
@@ -2220,7 +2220,7 @@ UpdateVariable (
                VariableGlobal,\r
                Variable->Volatile,\r
                Instance,\r
-               (UINTN) &(((VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
+               (UINTN) &(((AUTHENTICATED_VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
                sizeof (UINT8),\r
                &State\r
                );\r
@@ -2277,13 +2277,13 @@ EsalGetVariable (
   IN      ESAL_VARIABLE_GLOBAL  *Global\r
   )\r
 {\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-  UINTN                   VarDataSize;\r
-  EFI_STATUS              Status;\r
-  VARIABLE_HEADER         VariableHeader;\r
-  BOOLEAN                 Valid;\r
-  VARIABLE_GLOBAL         *VariableGlobal;\r
-  UINT32                  Instance;\r
+  VARIABLE_POINTER_TRACK            Variable;\r
+  UINTN                             VarDataSize;\r
+  EFI_STATUS                        Status;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
+  BOOLEAN                           Valid;\r
+  VARIABLE_GLOBAL                   *VariableGlobal;\r
+  UINT32                            Instance;\r
 \r
   if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {\r
     return EFI_INVALID_PARAMETER;\r
@@ -2400,12 +2400,12 @@ EsalGetNextVariableName (
   IN      ESAL_VARIABLE_GLOBAL  *Global\r
   )\r
 {\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-  UINTN                   VarNameSize;\r
-  EFI_STATUS              Status;\r
-  VARIABLE_HEADER         VariableHeader;\r
-  VARIABLE_GLOBAL         *VariableGlobal;\r
-  UINT32                  Instance;\r
+  VARIABLE_POINTER_TRACK            Variable;\r
+  UINTN                             VarNameSize;\r
+  EFI_STATUS                        Status;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
+  VARIABLE_GLOBAL                   *VariableGlobal;\r
+  UINT32                            Instance;\r
 \r
   if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {\r
     return EFI_INVALID_PARAMETER;\r
@@ -2607,7 +2607,7 @@ EsalSetVariable (
     // For variable for hardware error record, the size of the VariableName, including the Unicode Null\r
     // in bytes plus the DataSize is limited to maximum size of PcdGet32(PcdMaxHardwareErrorVariableSize) bytes.\r
     //\r
-    if (StrSize (VariableName) + PayloadSize > PcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER)) {\r
+    if (StrSize (VariableName) + PayloadSize > PcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER)) {\r
       return EFI_INVALID_PARAMETER;\r
     }\r
     //\r
@@ -2623,7 +2623,7 @@ EsalSetVariable (
     // For variable not for hardware error record, the size of the VariableName, including the\r
     // Unicode Null in bytes plus the DataSize is limited to maximum size of PcdGet32(PcdMaxVariableSize) bytes.\r
     //\r
-    if (StrSize (VariableName) + PayloadSize > PcdGet32(PcdMaxVariableSize) - sizeof (VARIABLE_HEADER)) {\r
+    if (StrSize (VariableName) + PayloadSize > PcdGet32(PcdMaxVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER)) {\r
       return EFI_INVALID_PARAMETER;\r
     }  \r
   }  \r
@@ -2746,17 +2746,17 @@ EsalQueryVariableInfo (
   IN  ESAL_VARIABLE_GLOBAL   *Global\r
   )\r
 {\r
-  EFI_PHYSICAL_ADDRESS   Variable;\r
-  EFI_PHYSICAL_ADDRESS   NextVariable;\r
-  UINT64                 VariableSize;\r
-  EFI_PHYSICAL_ADDRESS   VariableStoreHeaderAddress;\r
-  BOOLEAN                Volatile;\r
-  VARIABLE_STORE_HEADER  VarStoreHeader;\r
-  VARIABLE_HEADER        VariableHeader;\r
-  UINT64                 CommonVariableTotalSize;\r
-  UINT64                 HwErrVariableTotalSize;\r
-  VARIABLE_GLOBAL        *VariableGlobal;\r
-  UINT32                 Instance;\r
+  EFI_PHYSICAL_ADDRESS              Variable;\r
+  EFI_PHYSICAL_ADDRESS              NextVariable;\r
+  UINT64                            VariableSize;\r
+  EFI_PHYSICAL_ADDRESS              VariableStoreHeaderAddress;\r
+  BOOLEAN                           Volatile;\r
+  VARIABLE_STORE_HEADER             VarStoreHeader;\r
+  AUTHENTICATED_VARIABLE_HEADER     VariableHeader;\r
+  UINT64                            CommonVariableTotalSize;\r
+  UINT64                            HwErrVariableTotalSize;\r
+  VARIABLE_GLOBAL                   *VariableGlobal;\r
+  UINT32                            Instance;\r
 \r
   CommonVariableTotalSize = 0;\r
   HwErrVariableTotalSize = 0;\r
@@ -2818,7 +2818,7 @@ EsalQueryVariableInfo (
   //\r
   if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
     *MaximumVariableStorageSize = PcdGet32(PcdHwErrStorageSize);\r
-    *MaximumVariableSize = PcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER);\r
+    *MaximumVariableSize = PcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
   } else {\r
     if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
       ASSERT (PcdGet32(PcdHwErrStorageSize) < VarStoreHeader.Size);\r
@@ -2828,7 +2828,7 @@ EsalQueryVariableInfo (
     //\r
     // Let *MaximumVariableSize be PcdGet32(PcdMaxVariableSize) with the exception of the variable header size.\r
     //\r
-    *MaximumVariableSize = PcdGet32(PcdMaxVariableSize) - sizeof (VARIABLE_HEADER);\r
+    *MaximumVariableSize = PcdGet32(PcdMaxVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
   }\r
 \r
   //\r
@@ -2882,10 +2882,10 @@ EsalQueryVariableInfo (
     *RemainingVariableStorageSize = *MaximumVariableStorageSize - CommonVariableTotalSize;\r
   }\r
 \r
-  if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {\r
+  if (*RemainingVariableStorageSize < sizeof (AUTHENTICATED_VARIABLE_HEADER)) {\r
     *MaximumVariableSize = 0;\r
-  } else if ((*RemainingVariableStorageSize - sizeof (VARIABLE_HEADER)) < *MaximumVariableSize) {\r
-    *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);\r
+  } else if ((*RemainingVariableStorageSize - sizeof (AUTHENTICATED_VARIABLE_HEADER)) < *MaximumVariableSize) {\r
+    *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
   }\r
 \r
   ReleaseLockOnlyAtBootTime (&VariableGlobal->VariableServicesLock);\r
@@ -2955,7 +2955,7 @@ FlushHob2Nv (
   EFI_STATUS                      Status;\r
   VOID                            *GuidHob;\r
   VARIABLE_STORE_HEADER           *VariableStoreHeader;\r
-  VARIABLE_HEADER                 *VariableHeader;\r
+  AUTHENTICATED_VARIABLE_HEADER   *VariableHeader;\r
   //\r
   // Get HOB variable store.\r
   //\r
@@ -2970,11 +2970,11 @@ FlushHob2Nv (
       //\r
       // Flush the HOB variable to NV Variable storage.\r
       //\r
-      for ( VariableHeader = (VARIABLE_HEADER *) HEADER_ALIGN (VariableStoreHeader + 1)\r
-          ; (VariableHeader < (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VariableStoreHeader + VariableStoreHeader->Size)\r
+      for ( VariableHeader = (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN (VariableStoreHeader + 1)\r
+          ; (VariableHeader < (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VariableStoreHeader + VariableStoreHeader->Size)\r
             &&\r
             (VariableHeader->StartId == VARIABLE_DATA))\r
-          ; VariableHeader = (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) (VariableHeader + 1)\r
+          ; VariableHeader = (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) (VariableHeader + 1)\r
                            + VariableHeader->NameSize + GET_PAD_SIZE (VariableHeader->NameSize)\r
                            + VariableHeader->DataSize + GET_PAD_SIZE (VariableHeader->DataSize)\r
                            )\r
@@ -3198,7 +3198,7 @@ VariableCommonInitialize (
                        Instance\r
                        );\r
       VariableSize = NextVariable - Variable;\r
-      if ((((VARIABLE_HEADER *)Variable)->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+      if ((((AUTHENTICATED_VARIABLE_HEADER *)Variable)->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
         mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;\r
       } else {\r
         mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;\r
index 5e6690ed70fa272efae7ca86d1b5f98c1ca86fac..b32ef741bfd5dd69ffa541ae868674edfff7e039 100644 (file)
@@ -1,7 +1,7 @@
 /** @file\r
   Internal header file for Extended SAL variable service module.\r
 \r
-Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>\r
 This program and the accompanying materials \r
 are licensed and made available under the terms and conditions of the BSD License \r
 which accompanies this distribution.  The full text of the license may be found at \r
@@ -66,7 +66,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 /// The maximum size of the public key database, restricted by maximum individal EFI \r
 /// varible size, and excluding the variable header and name size.\r
 ///\r
-#define MAX_KEYDB_SIZE  (FixedPcdGet32 (PcdMaxVariableSize) - sizeof (VARIABLE_HEADER) - AUTHVAR_KEYDB_NAME_SIZE)\r
+#define MAX_KEYDB_SIZE  (FixedPcdGet32 (PcdMaxVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER) - AUTHVAR_KEYDB_NAME_SIZE)\r
 #define MAX_KEY_NUM     (MAX_KEYDB_SIZE / EFI_CERT_TYPE_RSA2048_SIZE)\r
 \r
 ///\r
@@ -432,7 +432,7 @@ GetVariableDataPtr (
 **/\r
 UINTN\r
 DataSizeOfVariable (\r
-  IN  VARIABLE_HEADER   *Variable\r
+  IN  AUTHENTICATED_VARIABLE_HEADER     *Variable\r
   );\r
 \r
 /**\r
@@ -479,7 +479,7 @@ UpdateVariable (
                                  FALSE - Variable is non-volatile.\r
   @param[in]  Global             Pointer to VARAIBLE_GLOBAL structure.\r
   @param[in]  Instance           Instance of FV Block services.\r
-  @param[out] VariableHeader     Pointer to VARIABLE_HEADER for output.\r
+  @param[out] VariableHeader     Pointer to AUTHENTICATED_VARIABLE_HEADER for output.\r
 \r
   @retval TRUE                   Variable header is valid.\r
   @retval FALSE                  Variable header is not valid.\r
@@ -487,11 +487,11 @@ UpdateVariable (
 **/\r
 BOOLEAN\r
 IsValidVariableHeader (\r
-  IN  EFI_PHYSICAL_ADDRESS   VariableAddress,\r
-  IN  BOOLEAN                Volatile,\r
-  IN  VARIABLE_GLOBAL        *Global,\r
-  IN  UINTN                  Instance,\r
-  OUT VARIABLE_HEADER        *VariableHeader  OPTIONAL\r
+  IN  EFI_PHYSICAL_ADDRESS              VariableAddress,\r
+  IN  BOOLEAN                           Volatile,\r
+  IN  VARIABLE_GLOBAL                   *Global,\r
+  IN  UINTN                             Instance,\r
+  OUT AUTHENTICATED_VARIABLE_HEADER     *VariableHeader  OPTIONAL\r
   );\r
 \r
 /**\r
diff --git a/SecurityPkg/VariableAuthenticated/Pei/PeiVariableAuth.uni b/SecurityPkg/VariableAuthenticated/Pei/PeiVariableAuth.uni
deleted file mode 100644 (file)
index 0fdc805..0000000
Binary files a/SecurityPkg/VariableAuthenticated/Pei/PeiVariableAuth.uni and /dev/null differ
diff --git a/SecurityPkg/VariableAuthenticated/Pei/PeiVariableExtra.uni b/SecurityPkg/VariableAuthenticated/Pei/PeiVariableExtra.uni
deleted file mode 100644 (file)
index c9f171b..0000000
Binary files a/SecurityPkg/VariableAuthenticated/Pei/PeiVariableExtra.uni and /dev/null differ
diff --git a/SecurityPkg/VariableAuthenticated/Pei/Variable.c b/SecurityPkg/VariableAuthenticated/Pei/Variable.c
deleted file mode 100644 (file)
index 7ee8b88..0000000
+++ /dev/null
@@ -1,1087 +0,0 @@
-/** @file\r
-  Implement ReadOnly Variable Services required by PEIM and install PEI\r
-  ReadOnly Varaiable2 PPI. These services operates the non-volatile \r
-  storage space.\r
-\r
-Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials \r
-are licensed and made available under the terms and conditions of the BSD License \r
-which accompanies this distribution.  The full text of the license may be found at \r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-\r
-#include "Variable.h"\r
-\r
-//\r
-// Module globals\r
-//\r
-EFI_PEI_READ_ONLY_VARIABLE2_PPI mVariablePpi = {\r
-  PeiGetVariable,\r
-  PeiGetNextVariableName\r
-};\r
-\r
-EFI_PEI_PPI_DESCRIPTOR     mPpiListVariable = {\r
-  (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),\r
-  &gEfiPeiReadOnlyVariable2PpiGuid,\r
-  &mVariablePpi\r
-};\r
-\r
-/**\r
-  Provide the functionality of the variable services.\r
-  \r
-  @param  FileHandle   Handle of the file being invoked. \r
-                       Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile().\r
-  @param  PeiServices  General purpose services available to every PEIM.\r
-\r
-  @retval EFI_SUCCESS  If the interface could be successfully installed\r
-  @retval Others       Returned from PeiServicesInstallPpi()\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-PeimInitializeVariableServices (\r
-  IN       EFI_PEI_FILE_HANDLE       FileHandle,\r
-  IN CONST EFI_PEI_SERVICES          **PeiServices\r
-  )\r
-{\r
-  return PeiServicesInstallPpi (&mPpiListVariable);\r
-}\r
-\r
-/**\r
-\r
-  Gets the pointer to the first variable header in given variable store area.\r
-\r
-  @param VarStoreHeader  Pointer to the Variable Store Header.\r
-\r
-  @return Pointer to the first variable header\r
-\r
-**/\r
-VARIABLE_HEADER *\r
-GetStartPointer (\r
-  IN VARIABLE_STORE_HEADER       *VarStoreHeader\r
-  )\r
-{\r
-  //\r
-  // The end of variable store\r
-  //\r
-  return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);\r
-}\r
-\r
-\r
-/**\r
-  This code gets the pointer to the last variable memory pointer byte.\r
-\r
-  @param  VarStoreHeader  Pointer to the Variable Store Header.\r
-\r
-  @return VARIABLE_HEADER* pointer to last unavailable Variable Header.\r
-\r
-**/\r
-VARIABLE_HEADER *\r
-GetEndPointer (\r
-  IN VARIABLE_STORE_HEADER       *VarStoreHeader\r
-  )\r
-{\r
-  //\r
-  // The end of variable store\r
-  //\r
-  return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);\r
-}\r
-\r
-\r
-/**\r
-  This code checks if variable header is valid or not.\r
-\r
-  @param  Variable  Pointer to the Variable Header.\r
-\r
-  @retval TRUE      Variable header is valid.\r
-  @retval FALSE     Variable header is not valid.\r
-\r
-**/\r
-BOOLEAN\r
-IsValidVariableHeader (\r
-  IN  VARIABLE_HEADER   *Variable\r
-  )\r
-{\r
-  if (Variable == NULL || Variable->StartId != VARIABLE_DATA ) {\r
-    return FALSE;\r
-  }\r
-\r
-  return TRUE;\r
-}\r
-\r
-\r
-/**\r
-  This code gets the size of name of variable.\r
-\r
-  @param  Variable  Pointer to the Variable Header.\r
-\r
-  @return Size of variable in bytes in type UINTN.\r
-\r
-**/\r
-UINTN\r
-NameSizeOfVariable (\r
-  IN  VARIABLE_HEADER   *Variable\r
-  )\r
-{\r
-  if (Variable->State    == (UINT8) (-1) ||\r
-      Variable->DataSize == (UINT32) (-1) ||\r
-      Variable->NameSize == (UINT32) (-1) ||\r
-      Variable->Attributes == (UINT32) (-1)) {\r
-    return 0;\r
-  }\r
-  return (UINTN) Variable->NameSize;\r
-}\r
-\r
-\r
-/**\r
-  This code gets the size of data of variable.\r
-\r
-  @param  Variable  Pointer to the Variable Header.\r
-\r
-  @return Size of variable in bytes in type UINTN.\r
-\r
-**/\r
-UINTN\r
-DataSizeOfVariable (\r
-  IN  VARIABLE_HEADER   *Variable\r
-  )\r
-{\r
-  if (Variable->State    == (UINT8)  (-1) ||\r
-      Variable->DataSize == (UINT32) (-1) ||\r
-      Variable->NameSize == (UINT32) (-1) ||\r
-      Variable->Attributes == (UINT32) (-1)) {\r
-    return 0;\r
-  }\r
-  return (UINTN) Variable->DataSize;\r
-}\r
-\r
-/**\r
-  This code gets the pointer to the variable name.\r
-\r
-  @param   Variable  Pointer to the Variable Header.\r
-\r
-  @return  A CHAR16* pointer to Variable Name.\r
-\r
-**/\r
-CHAR16 *\r
-GetVariableNamePtr (\r
-  IN  VARIABLE_HEADER   *Variable\r
-  )\r
-{\r
-  return (CHAR16 *) (Variable + 1);\r
-}\r
-\r
-\r
-/**\r
-  This code gets the pointer to the variable data.\r
-\r
-  @param   Variable         Pointer to the Variable Header.\r
-  @param   VariableHeader   Pointer to the Variable Header that has consecutive content.\r
-\r
-  @return  A UINT8* pointer to Variable Data.\r
-\r
-**/\r
-UINT8 *\r
-GetVariableDataPtr (\r
-  IN  VARIABLE_HEADER   *Variable,\r
-  IN  VARIABLE_HEADER   *VariableHeader\r
-  )\r
-{\r
-  UINTN Value;\r
-  \r
-  //\r
-  // Be careful about pad size for alignment\r
-  //\r
-  Value =  (UINTN) GetVariableNamePtr (Variable);\r
-  Value += NameSizeOfVariable (VariableHeader);\r
-  Value += GET_PAD_SIZE (NameSizeOfVariable (VariableHeader));\r
-\r
-  return (UINT8 *) Value;\r
-}\r
-\r
-\r
-/**\r
-  This code gets the pointer to the next variable header.\r
-\r
-  @param  StoreInfo         Pointer to variable store info structure.\r
-  @param  Variable          Pointer to the Variable Header.\r
-  @param  VariableHeader    Pointer to the Variable Header that has consecutive content.\r
-\r
-  @return  A VARIABLE_HEADER* pointer to next variable header.\r
-\r
-**/\r
-VARIABLE_HEADER *\r
-GetNextVariablePtr (\r
-  IN  VARIABLE_STORE_INFO   *StoreInfo,\r
-  IN  VARIABLE_HEADER       *Variable,\r
-  IN  VARIABLE_HEADER       *VariableHeader\r
-  )\r
-{\r
-  EFI_PHYSICAL_ADDRESS  TargetAddress;\r
-  EFI_PHYSICAL_ADDRESS  SpareAddress;\r
-  UINTN                 Value;\r
-\r
-  Value =  (UINTN) GetVariableDataPtr (Variable, VariableHeader);\r
-  Value += DataSizeOfVariable (VariableHeader);\r
-  Value += GET_PAD_SIZE (DataSizeOfVariable (VariableHeader));\r
-  //\r
-  // Be careful about pad size for alignment\r
-  //\r
-  Value = HEADER_ALIGN (Value);\r
-\r
-  if (StoreInfo->FtwLastWriteData != NULL) {\r
-    TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;\r
-    SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;\r
-    if (((UINTN) Variable < (UINTN) TargetAddress) && (Value >= (UINTN) TargetAddress)) {\r
-      //\r
-      // Next variable is in spare block.\r
-      //\r
-      Value = (UINTN) SpareAddress + (Value - (UINTN) TargetAddress);\r
-    }\r
-  }\r
-\r
-  return (VARIABLE_HEADER *) Value;\r
-}\r
-\r
-/**\r
-  Get variable store status.\r
-\r
-  @param  VarStoreHeader  Pointer to the Variable Store Header.\r
-\r
-  @retval  EfiRaw      Variable store is raw\r
-  @retval  EfiValid    Variable store is valid\r
-  @retval  EfiInvalid  Variable store is invalid\r
-\r
-**/\r
-VARIABLE_STORE_STATUS\r
-GetVariableStoreStatus (\r
-  IN VARIABLE_STORE_HEADER *VarStoreHeader\r
-  )\r
-{\r
-  if (CompareGuid (&VarStoreHeader->Signature, &gEfiAuthenticatedVariableGuid) &&\r
-      VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&\r
-      VarStoreHeader->State == VARIABLE_STORE_HEALTHY\r
-      ) {\r
-\r
-    return EfiValid;\r
-  }\r
-\r
-  if (((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff &&\r
-      ((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff &&\r
-      ((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff &&\r
-      ((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff &&\r
-      VarStoreHeader->Size == 0xffffffff &&\r
-      VarStoreHeader->Format == 0xff &&\r
-      VarStoreHeader->State == 0xff\r
-      ) {\r
-\r
-    return EfiRaw;\r
-  } else {\r
-    return EfiInvalid;\r
-  }\r
-}\r
-\r
-/**\r
-  Compare two variable names, one of them may be inconsecutive.\r
-\r
-  @param StoreInfo      Pointer to variable store info structure.\r
-  @param Name1          Pointer to one variable name.\r
-  @param Name2          Pointer to another variable name.\r
-  @param NameSize       Variable name size.\r
-\r
-  @retval TRUE          Name1 and Name2 are identical.\r
-  @retval FALSE         Name1 and Name2 are not identical.\r
-\r
-**/\r
-BOOLEAN\r
-CompareVariableName (\r
-  IN VARIABLE_STORE_INFO    *StoreInfo,\r
-  IN CONST CHAR16           *Name1,\r
-  IN CONST CHAR16           *Name2,\r
-  IN UINTN                  NameSize\r
-  )\r
-{\r
-  EFI_PHYSICAL_ADDRESS  TargetAddress;\r
-  EFI_PHYSICAL_ADDRESS  SpareAddress;\r
-  UINTN                 PartialNameSize;\r
-\r
-  if (StoreInfo->FtwLastWriteData != NULL) {\r
-    TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;\r
-    SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;\r
-    if (((UINTN) Name1 < (UINTN) TargetAddress) && (((UINTN) Name1 + NameSize) > (UINTN) TargetAddress)) {\r
-      //\r
-      // Name1 is inconsecutive.\r
-      //\r
-      PartialNameSize = (UINTN) TargetAddress - (UINTN) Name1;\r
-      //\r
-      // Partial content is in NV storage.\r
-      //\r
-      if (CompareMem ((UINT8 *) Name1, (UINT8 *) Name2, PartialNameSize) == 0) {\r
-        //\r
-        // Another partial content is in spare block.\r
-        //\r
-        if (CompareMem ((UINT8 *) (UINTN) SpareAddress, (UINT8 *) Name2 + PartialNameSize, NameSize - PartialNameSize) == 0) {\r
-          return TRUE;\r
-        }\r
-      }\r
-      return FALSE;\r
-    } else if (((UINTN) Name2 < (UINTN) TargetAddress) && (((UINTN) Name2 + NameSize) > (UINTN) TargetAddress)) {\r
-      //\r
-      // Name2 is inconsecutive.\r
-      //\r
-      PartialNameSize = (UINTN) TargetAddress - (UINTN) Name2;\r
-      //\r
-      // Partial content is in NV storage.\r
-      //\r
-      if (CompareMem ((UINT8 *) Name2, (UINT8 *) Name1, PartialNameSize) == 0) {\r
-        //\r
-        // Another partial content is in spare block.\r
-        //\r
-        if (CompareMem ((UINT8 *) (UINTN) SpareAddress, (UINT8 *) Name1 + PartialNameSize, NameSize - PartialNameSize) == 0) {\r
-          return TRUE;\r
-        }\r
-      }\r
-      return FALSE;\r
-    }\r
-  }\r
-\r
-  //\r
-  // Both Name1 and Name2 are consecutive.\r
-  //\r
-  if (CompareMem ((UINT8 *) Name1, (UINT8 *) Name2, NameSize) == 0) {\r
-    return TRUE;\r
-  }\r
-  return FALSE;\r
-}\r
-\r
-/**\r
-  This function compares a variable with variable entries in database.\r
-\r
-  @param  StoreInfo     Pointer to variable store info structure.\r
-  @param  Variable      Pointer to the variable in our database\r
-  @param  VariableHeader Pointer to the Variable Header that has consecutive content.\r
-  @param  VariableName  Name of the variable to compare to 'Variable'\r
-  @param  VendorGuid    GUID of the variable to compare to 'Variable'\r
-  @param  PtrTrack      Variable Track Pointer structure that contains Variable Information.\r
-\r
-  @retval EFI_SUCCESS    Found match variable\r
-  @retval EFI_NOT_FOUND  Variable not found\r
-\r
-**/\r
-EFI_STATUS\r
-CompareWithValidVariable (\r
-  IN  VARIABLE_STORE_INFO           *StoreInfo,\r
-  IN  VARIABLE_HEADER               *Variable,\r
-  IN  VARIABLE_HEADER               *VariableHeader,\r
-  IN  CONST CHAR16                  *VariableName,\r
-  IN  CONST EFI_GUID                *VendorGuid,\r
-  OUT VARIABLE_POINTER_TRACK        *PtrTrack\r
-  )\r
-{\r
-  VOID  *Point;\r
-\r
-  if (VariableName[0] == 0) {\r
-    PtrTrack->CurrPtr = Variable;\r
-    return EFI_SUCCESS;\r
-  } else {\r
-    //\r
-    // Don't use CompareGuid function here for performance reasons.\r
-    // Instead we compare the GUID a UINT32 at a time and branch\r
-    // on the first failed comparison.\r
-    //\r
-    if ((((INT32 *) VendorGuid)[0] == ((INT32 *) &VariableHeader->VendorGuid)[0]) &&\r
-        (((INT32 *) VendorGuid)[1] == ((INT32 *) &VariableHeader->VendorGuid)[1]) &&\r
-        (((INT32 *) VendorGuid)[2] == ((INT32 *) &VariableHeader->VendorGuid)[2]) &&\r
-        (((INT32 *) VendorGuid)[3] == ((INT32 *) &VariableHeader->VendorGuid)[3])\r
-        ) {\r
-      ASSERT (NameSizeOfVariable (VariableHeader) != 0);\r
-      Point = (VOID *) GetVariableNamePtr (Variable);\r
-      if (CompareVariableName (StoreInfo, VariableName, Point, NameSizeOfVariable (VariableHeader))) {\r
-        PtrTrack->CurrPtr = Variable;\r
-        return EFI_SUCCESS;\r
-      }\r
-    }\r
-  }\r
-\r
-  return EFI_NOT_FOUND;\r
-}\r
-\r
-/**\r
-  Return the variable store header and the store info based on the Index.\r
-\r
-  @param Type       The type of the variable store.\r
-  @param StoreInfo  Return the store info.\r
-\r
-  @return  Pointer to the variable store header.\r
-**/\r
-VARIABLE_STORE_HEADER *\r
-GetVariableStore (\r
-  IN VARIABLE_STORE_TYPE         Type,\r
-  OUT VARIABLE_STORE_INFO        *StoreInfo\r
-  )\r
-{\r
-  EFI_HOB_GUID_TYPE                     *GuidHob;\r
-  EFI_FIRMWARE_VOLUME_HEADER            *FvHeader;\r
-  VARIABLE_STORE_HEADER                 *VariableStoreHeader;\r
-  EFI_PHYSICAL_ADDRESS                  NvStorageBase;\r
-  UINT32                                NvStorageSize;\r
-  FAULT_TOLERANT_WRITE_LAST_WRITE_DATA  *FtwLastWriteData;\r
-  UINT32                                BackUpOffset;\r
-\r
-  StoreInfo->IndexTable = NULL;\r
-  StoreInfo->FtwLastWriteData = NULL;\r
-  VariableStoreHeader = NULL;\r
-  switch (Type) {\r
-    case VariableStoreTypeHob:\r
-      GuidHob     = GetFirstGuidHob (&gEfiAuthenticatedVariableGuid);\r
-      if (GuidHob != NULL) {\r
-        VariableStoreHeader = (VARIABLE_STORE_HEADER *) GET_GUID_HOB_DATA (GuidHob);\r
-      }\r
-      break;\r
-\r
-    case VariableStoreTypeNv:\r
-      if (GetBootModeHob () != BOOT_IN_RECOVERY_MODE) {\r
-        //\r
-        // The content of NV storage for variable is not reliable in recovery boot mode.\r
-        //\r
-\r
-        NvStorageSize = PcdGet32 (PcdFlashNvStorageVariableSize);\r
-        NvStorageBase = (EFI_PHYSICAL_ADDRESS) (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0 ? \r
-                                                PcdGet64 (PcdFlashNvStorageVariableBase64) : \r
-                                                PcdGet32 (PcdFlashNvStorageVariableBase)\r
-                                               );\r
-        //\r
-        // First let FvHeader point to NV storage base.\r
-        //\r
-        FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) NvStorageBase;\r
-\r
-        //\r
-        // Check the FTW last write data hob.\r
-        //\r
-        BackUpOffset = 0;\r
-        GuidHob = GetFirstGuidHob (&gEdkiiFaultTolerantWriteGuid);\r
-        if (GuidHob != NULL) {\r
-          FtwLastWriteData = (FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *) GET_GUID_HOB_DATA (GuidHob);\r
-          if (FtwLastWriteData->TargetAddress == NvStorageBase) {\r
-            //\r
-            // Let FvHeader point to spare block.\r
-            //\r
-            FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) FtwLastWriteData->SpareAddress;\r
-            DEBUG ((EFI_D_INFO, "PeiVariable: NV storage is backed up in spare block: 0x%x\n", (UINTN) FtwLastWriteData->SpareAddress));\r
-          } else if ((FtwLastWriteData->TargetAddress > NvStorageBase) && (FtwLastWriteData->TargetAddress < (NvStorageBase + NvStorageSize))) {\r
-            StoreInfo->FtwLastWriteData = FtwLastWriteData;\r
-            //\r
-            // Flash NV storage from the offset is backed up in spare block.\r
-            //\r
-            BackUpOffset = (UINT32) (FtwLastWriteData->TargetAddress - NvStorageBase);\r
-            DEBUG ((EFI_D_INFO, "PeiVariable: High partial NV storage from offset: %x is backed up in spare block: 0x%x\n", BackUpOffset, (UINTN) FtwLastWriteData->SpareAddress));\r
-            //\r
-            // At least one block data in flash NV storage is still valid, so still leave FvHeader point to NV storage base.\r
-            //\r
-          }\r
-        }\r
-\r
-        //\r
-        // Check if the Firmware Volume is not corrupted\r
-        //\r
-        if ((FvHeader->Signature != EFI_FVH_SIGNATURE) || (!CompareGuid (&gEfiSystemNvDataFvGuid, &FvHeader->FileSystemGuid))) {\r
-          DEBUG ((EFI_D_ERROR, "Firmware Volume for Variable Store is corrupted\n"));\r
-          break;\r
-        }\r
-        \r
-        VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINT8 *) FvHeader + FvHeader->HeaderLength);\r
-\r
-        GuidHob = GetFirstGuidHob (&gEfiVariableIndexTableGuid);\r
-        if (GuidHob != NULL) {\r
-          StoreInfo->IndexTable = GET_GUID_HOB_DATA (GuidHob);\r
-        } else {\r
-          //\r
-          // If it's the first time to access variable region in flash, create a guid hob to record\r
-          // VAR_ADDED type variable info.\r
-          // Note that as the resource of PEI phase is limited, only store the limited number of \r
-          // VAR_ADDED type variables to reduce access time.\r
-          //\r
-          StoreInfo->IndexTable = (VARIABLE_INDEX_TABLE *) BuildGuidHob (&gEfiVariableIndexTableGuid, sizeof (VARIABLE_INDEX_TABLE));\r
-          StoreInfo->IndexTable->Length      = 0;\r
-          StoreInfo->IndexTable->StartPtr    = GetStartPointer (VariableStoreHeader);\r
-          StoreInfo->IndexTable->EndPtr      = GetEndPointer   (VariableStoreHeader);\r
-          StoreInfo->IndexTable->GoneThrough = 0;\r
-        }\r
-      }\r
-      break;\r
-\r
-    default:\r
-      ASSERT (FALSE);\r
-      break;\r
-  }\r
-\r
-  StoreInfo->VariableStoreHeader = VariableStoreHeader;\r
-  return VariableStoreHeader;\r
-}\r
-\r
-/**\r
-  Get variable header that has consecutive content.\r
-\r
-  @param StoreInfo      Pointer to variable store info structure.\r
-  @param Variable       Pointer to the Variable Header.\r
-  @param VariableHeader Pointer to Pointer to the Variable Header that has consecutive content.\r
-\r
-  @retval TRUE          Variable header is valid.\r
-  @retval FALSE         Variable header is not valid.\r
-\r
-**/\r
-BOOLEAN\r
-GetVariableHeader (\r
-  IN VARIABLE_STORE_INFO    *StoreInfo,\r
-  IN VARIABLE_HEADER        *Variable,\r
-  OUT VARIABLE_HEADER       **VariableHeader\r
-  )\r
-{\r
-  EFI_PHYSICAL_ADDRESS  TargetAddress;\r
-  EFI_PHYSICAL_ADDRESS  SpareAddress;\r
-  EFI_HOB_GUID_TYPE     *GuidHob;\r
-  UINTN                 PartialHeaderSize;\r
-\r
-  if (Variable == NULL) {\r
-    return FALSE;\r
-  }\r
-\r
-   //\r
-   // First assume variable header pointed by Variable is consecutive.\r
-   //\r
-  *VariableHeader = Variable;\r
-\r
-  if (StoreInfo->FtwLastWriteData != NULL) {\r
-    TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;\r
-    SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;\r
-    if (((UINTN) Variable > (UINTN) SpareAddress) &&\r
-        (((UINTN) Variable - (UINTN) SpareAddress + (UINTN) TargetAddress) >= (UINTN) GetEndPointer (StoreInfo->VariableStoreHeader))) {\r
-      //\r
-      // Reach the end of variable store.\r
-      //\r
-      return FALSE;\r
-    }\r
-    if (((UINTN) Variable < (UINTN) TargetAddress) && (((UINTN) Variable + sizeof (VARIABLE_HEADER)) > (UINTN) TargetAddress)) {\r
-      //\r
-      // Variable header pointed by Variable is inconsecutive,\r
-      // create a guid hob to combine the two partial variable header content together.\r
-      //\r
-      GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);\r
-      if (GuidHob != NULL) {\r
-        *VariableHeader = (VARIABLE_HEADER *) GET_GUID_HOB_DATA (GuidHob);\r
-      } else {\r
-        *VariableHeader = (VARIABLE_HEADER *) BuildGuidHob (&gEfiCallerIdGuid, sizeof (VARIABLE_HEADER));\r
-        PartialHeaderSize = (UINTN) TargetAddress - (UINTN) Variable;\r
-        //\r
-        // Partial content is in NV storage.\r
-        //\r
-        CopyMem ((UINT8 *) *VariableHeader, (UINT8 *) Variable, PartialHeaderSize);\r
-        //\r
-        // Another partial content is in spare block.\r
-        //\r
-        CopyMem ((UINT8 *) *VariableHeader + PartialHeaderSize, (UINT8 *) (UINTN) SpareAddress, sizeof (VARIABLE_HEADER) - PartialHeaderSize);\r
-      }\r
-    }\r
-  } else {\r
-    if (Variable >= GetEndPointer (StoreInfo->VariableStoreHeader)) {\r
-      //\r
-      // Reach the end of variable store.\r
-      //\r
-      return FALSE;\r
-    }\r
-  }\r
-\r
-  return IsValidVariableHeader (*VariableHeader);\r
-}\r
-\r
-/**\r
-  Get variable name or data to output buffer.\r
-\r
-  @param  StoreInfo     Pointer to variable store info structure.\r
-  @param  NameOrData    Pointer to the variable name/data that may be inconsecutive.\r
-  @param  Size          Variable name/data size.\r
-  @param  Buffer        Pointer to output buffer to hold the variable name/data.\r
-\r
-**/\r
-VOID\r
-GetVariableNameOrData (\r
-  IN VARIABLE_STORE_INFO    *StoreInfo,\r
-  IN UINT8                  *NameOrData,\r
-  IN UINTN                  Size,\r
-  OUT UINT8                 *Buffer\r
-  )\r
-{\r
-  EFI_PHYSICAL_ADDRESS  TargetAddress;\r
-  EFI_PHYSICAL_ADDRESS  SpareAddress;\r
-  UINTN                 PartialSize;\r
\r
-  if (StoreInfo->FtwLastWriteData != NULL) {\r
-    TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;\r
-    SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;\r
-    if (((UINTN) NameOrData < (UINTN) TargetAddress) && (((UINTN) NameOrData + Size) > (UINTN) TargetAddress)) {\r
-      //\r
-      // Variable name/data is inconsecutive.\r
-      //\r
-      PartialSize = (UINTN) TargetAddress - (UINTN) NameOrData;\r
-      //\r
-      // Partial content is in NV storage.\r
-      //\r
-      CopyMem (Buffer, NameOrData, PartialSize);\r
-      //\r
-      // Another partial content is in spare block.\r
-      //\r
-      CopyMem (Buffer + PartialSize, (UINT8 *) (UINTN) SpareAddress, Size - PartialSize);\r
-      return;\r
-    }\r
-  }\r
-\r
-  //\r
-  // Variable name/data is consecutive.\r
-  //\r
-  CopyMem (Buffer, NameOrData, Size);\r
-}\r
-\r
-/**\r
-  Find the variable in the specified variable store.\r
-\r
-  @param  StoreInfo           Pointer to the store info structure.\r
-  @param  VariableName        Name of the variable to be found\r
-  @param  VendorGuid          Vendor GUID to be found.\r
-  @param  PtrTrack            Variable Track Pointer structure that contains Variable Information.\r
-\r
-  @retval  EFI_SUCCESS            Variable found successfully\r
-  @retval  EFI_NOT_FOUND          Variable not found\r
-  @retval  EFI_INVALID_PARAMETER  Invalid variable name\r
-\r
-**/\r
-EFI_STATUS\r
-FindVariableEx (\r
-  IN VARIABLE_STORE_INFO         *StoreInfo,\r
-  IN CONST CHAR16                *VariableName,\r
-  IN CONST EFI_GUID              *VendorGuid,\r
-  OUT VARIABLE_POINTER_TRACK     *PtrTrack\r
-  )\r
-{\r
-  VARIABLE_HEADER         *Variable;\r
-  VARIABLE_HEADER         *LastVariable;\r
-  VARIABLE_HEADER         *MaxIndex;\r
-  UINTN                   Index;\r
-  UINTN                   Offset;\r
-  BOOLEAN                 StopRecord;\r
-  VARIABLE_HEADER         *InDeletedVariable;\r
-  VARIABLE_STORE_HEADER   *VariableStoreHeader;\r
-  VARIABLE_INDEX_TABLE    *IndexTable;\r
-  VARIABLE_HEADER         *VariableHeader;\r
-\r
-  VariableStoreHeader = StoreInfo->VariableStoreHeader;\r
-\r
-  if (VariableStoreHeader == NULL) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  if (GetVariableStoreStatus (VariableStoreHeader) != EfiValid) {\r
-    return EFI_UNSUPPORTED;\r
-  }\r
-\r
-  if (~VariableStoreHeader->Size == 0) {\r
-    return EFI_NOT_FOUND;\r
-  }\r
-\r
-  IndexTable = StoreInfo->IndexTable;\r
-  PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader);\r
-  PtrTrack->EndPtr   = GetEndPointer   (VariableStoreHeader);\r
-\r
-  InDeletedVariable = NULL;\r
-\r
-  //\r
-  // No Variable Address equals zero, so 0 as initial value is safe.\r
-  //\r
-  MaxIndex   = NULL;\r
-  VariableHeader = NULL;\r
-\r
-  if (IndexTable != NULL) {\r
-    //\r
-    // traverse the variable index table to look for varible.\r
-    // The IndexTable->Index[Index] records the distance of two neighbouring VAR_ADDED type variables.\r
-    //\r
-    for (Offset = 0, Index = 0; Index < IndexTable->Length; Index++) {\r
-      ASSERT (Index < sizeof (IndexTable->Index) / sizeof (IndexTable->Index[0]));\r
-      Offset   += IndexTable->Index[Index];\r
-      MaxIndex  = (VARIABLE_HEADER *) ((UINT8 *) IndexTable->StartPtr + Offset);\r
-      GetVariableHeader (StoreInfo, MaxIndex, &VariableHeader);\r
-      if (CompareWithValidVariable (StoreInfo, MaxIndex, VariableHeader, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {\r
-        if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
-          InDeletedVariable = PtrTrack->CurrPtr;\r
-        } else {\r
-          return EFI_SUCCESS;\r
-        }\r
-      }\r
-    }\r
-\r
-    if (IndexTable->GoneThrough != 0) {\r
-      //\r
-      // If the table has all the existing variables indexed, return.\r
-      //\r
-      PtrTrack->CurrPtr = InDeletedVariable;\r
-      return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;\r
-    }\r
-  }\r
-\r
-  if (MaxIndex != NULL) {\r
-    //\r
-    // HOB exists but the variable cannot be found in HOB\r
-    // If not found in HOB, then let's start from the MaxIndex we've found.\r
-    //\r
-    Variable     = GetNextVariablePtr (StoreInfo, MaxIndex, VariableHeader);\r
-    LastVariable = MaxIndex;\r
-  } else {\r
-    //\r
-    // Start Pointers for the variable.\r
-    // Actual Data Pointer where data can be written.\r
-    //\r
-    Variable     = PtrTrack->StartPtr;\r
-    LastVariable = PtrTrack->StartPtr;\r
-  }\r
-\r
-  //\r
-  // Find the variable by walk through variable store\r
-  //\r
-  StopRecord = FALSE;\r
-  while (GetVariableHeader (StoreInfo, Variable, &VariableHeader)) {\r
-    if (VariableHeader->State == VAR_ADDED || VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
-      //\r
-      // Record Variable in VariableIndex HOB\r
-      //\r
-      if ((IndexTable != NULL) && !StopRecord) {\r
-        Offset = (UINTN) Variable - (UINTN) LastVariable;\r
-        if ((Offset > 0x0FFFF) || (IndexTable->Length == sizeof (IndexTable->Index) / sizeof (IndexTable->Index[0]))) {\r
-          //\r
-          // Stop to record if the distance of two neighbouring VAR_ADDED variable is larger than the allowable scope(UINT16),\r
-          // or the record buffer is full.\r
-          //\r
-          StopRecord = TRUE;\r
-        } else {\r
-          IndexTable->Index[IndexTable->Length++] = (UINT16) Offset;\r
-          LastVariable = Variable;\r
-        }\r
-      }\r
-\r
-      if (CompareWithValidVariable (StoreInfo, Variable, VariableHeader, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {\r
-        if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
-          InDeletedVariable = PtrTrack->CurrPtr;\r
-        } else {\r
-          return EFI_SUCCESS;\r
-        }\r
-      }\r
-    }\r
-\r
-    Variable = GetNextVariablePtr (StoreInfo, Variable, VariableHeader);\r
-  }\r
-  //\r
-  // If gone through the VariableStore, that means we never find in Firmware any more.\r
-  //\r
-  if ((IndexTable != NULL) && !StopRecord) {\r
-    IndexTable->GoneThrough = 1;\r
-  }\r
-\r
-  PtrTrack->CurrPtr = InDeletedVariable;\r
-\r
-  return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Find the variable in HOB and Non-Volatile variable storages.\r
-\r
-  @param  VariableName  Name of the variable to be found\r
-  @param  VendorGuid    Vendor GUID to be found.\r
-  @param  PtrTrack      Variable Track Pointer structure that contains Variable Information.\r
-  @param  StoreInfo     Return the store info.\r
-\r
-  @retval  EFI_SUCCESS            Variable found successfully\r
-  @retval  EFI_NOT_FOUND          Variable not found\r
-  @retval  EFI_INVALID_PARAMETER  Invalid variable name\r
-**/\r
-EFI_STATUS\r
-FindVariable (\r
-  IN CONST  CHAR16            *VariableName,\r
-  IN CONST  EFI_GUID          *VendorGuid,\r
-  OUT VARIABLE_POINTER_TRACK  *PtrTrack,\r
-  OUT VARIABLE_STORE_INFO     *StoreInfo\r
-  )\r
-{\r
-  EFI_STATUS                  Status;\r
-  VARIABLE_STORE_TYPE         Type;\r
-\r
-  if (VariableName[0] != 0 && VendorGuid == NULL) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {\r
-    GetVariableStore (Type, StoreInfo);\r
-    Status = FindVariableEx (\r
-               StoreInfo,\r
-               VariableName,\r
-               VendorGuid, \r
-               PtrTrack\r
-               );\r
-    if (!EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-  }\r
-\r
-  return EFI_NOT_FOUND;\r
-}\r
-\r
-/**\r
-  This service retrieves a variable's value using its name and GUID.\r
-\r
-  Read the specified variable from the UEFI variable store. If the Data \r
-  buffer is too small to hold the contents of the variable, the error\r
-  EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer\r
-  size to obtain the data.\r
-\r
-  @param  This                  A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.\r
-  @param  VariableName          A pointer to a null-terminated string that is the variable's name.\r
-  @param  VariableGuid          A pointer to an EFI_GUID that is the variable's GUID. The combination of\r
-                                VariableGuid and VariableName must be unique.\r
-  @param  Attributes            If non-NULL, on return, points to the variable's attributes.\r
-  @param  DataSize              On entry, points to the size in bytes of the Data buffer.\r
-                                On return, points to the size of the data returned in Data.\r
-  @param  Data                  Points to the buffer which will hold the returned variable value.\r
-\r
-  @retval EFI_SUCCESS           The variable was read successfully.\r
-  @retval EFI_NOT_FOUND         The variable could not be found.\r
-  @retval EFI_BUFFER_TOO_SMALL  The DataSize is too small for the resulting data. \r
-                                DataSize is updated with the size required for \r
-                                the specified variable.\r
-  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.\r
-  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-PeiGetVariable (\r
-  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,\r
-  IN CONST  CHAR16                          *VariableName,\r
-  IN CONST  EFI_GUID                        *VariableGuid,\r
-  OUT       UINT32                          *Attributes,\r
-  IN OUT    UINTN                           *DataSize,\r
-  OUT       VOID                            *Data\r
-  )\r
-{\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-  UINTN                   VarDataSize;\r
-  EFI_STATUS              Status;\r
-  VARIABLE_STORE_INFO     StoreInfo;\r
-  VARIABLE_HEADER         *VariableHeader;\r
-\r
-  if (VariableName == NULL || VariableGuid == NULL || DataSize == NULL) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  VariableHeader = NULL;\r
-\r
-  //\r
-  // Find existing variable\r
-  //\r
-  Status = FindVariable (VariableName, VariableGuid, &Variable, &StoreInfo);\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-  GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader);\r
-\r
-  //\r
-  // Get data size\r
-  //\r
-  VarDataSize = DataSizeOfVariable (VariableHeader);\r
-  if (*DataSize >= VarDataSize) {\r
-    if (Data == NULL) {\r
-      return EFI_INVALID_PARAMETER;\r
-    }\r
-\r
-    GetVariableNameOrData (&StoreInfo, GetVariableDataPtr (Variable.CurrPtr, VariableHeader), VarDataSize, Data);\r
-\r
-    if (Attributes != NULL) {\r
-      *Attributes = VariableHeader->Attributes;\r
-    }\r
-\r
-    *DataSize = VarDataSize;\r
-    return EFI_SUCCESS;\r
-  } else {\r
-    *DataSize = VarDataSize;\r
-    return EFI_BUFFER_TOO_SMALL;\r
-  }\r
-}\r
-\r
-/**\r
-  Return the next variable name and GUID.\r
-\r
-  This function is called multiple times to retrieve the VariableName \r
-  and VariableGuid of all variables currently available in the system. \r
-  On each call, the previous results are passed into the interface, \r
-  and, on return, the interface returns the data for the next \r
-  interface. When the entire variable list has been returned, \r
-  EFI_NOT_FOUND is returned.\r
-\r
-  @param  This              A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.\r
-\r
-  @param  VariableNameSize  On entry, points to the size of the buffer pointed to by VariableName.\r
-                            On return, the size of the variable name buffer.\r
-  @param  VariableName      On entry, a pointer to a null-terminated string that is the variable's name.\r
-                            On return, points to the next variable's null-terminated name string.\r
-  @param  VariableGuid      On entry, a pointer to an EFI_GUID that is the variable's GUID. \r
-                            On return, a pointer to the next variable's GUID.\r
-\r
-  @retval EFI_SUCCESS           The variable was read successfully.\r
-  @retval EFI_NOT_FOUND         The variable could not be found.\r
-  @retval EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the resulting\r
-                                data. VariableNameSize is updated with the size\r
-                                required for the specified variable.\r
-  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or\r
-                                VariableNameSize is NULL.\r
-  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-PeiGetNextVariableName (\r
-  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,\r
-  IN OUT UINTN                              *VariableNameSize,\r
-  IN OUT CHAR16                             *VariableName,\r
-  IN OUT EFI_GUID                           *VariableGuid\r
-  )\r
-{\r
-  VARIABLE_STORE_TYPE     Type;\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-  VARIABLE_POINTER_TRACK  VariableInHob;\r
-  VARIABLE_POINTER_TRACK  VariablePtrTrack;\r
-  UINTN                   VarNameSize;\r
-  EFI_STATUS              Status;\r
-  VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];\r
-  VARIABLE_HEADER         *VariableHeader;\r
-  VARIABLE_STORE_INFO     StoreInfo;\r
-  VARIABLE_STORE_INFO     StoreInfoForNv;\r
-  VARIABLE_STORE_INFO     StoreInfoForHob;\r
-\r
-  if (VariableName == NULL || VariableGuid == NULL || VariableNameSize == NULL) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  VariableHeader = NULL;\r
-\r
-  Status = FindVariable (VariableName, VariableGuid, &Variable, &StoreInfo);\r
-  if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {\r
-    return Status;\r
-  }\r
-\r
-  if (VariableName[0] != 0) {\r
-    //\r
-    // If variable name is not NULL, get next variable\r
-    //\r
-    GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader);\r
-    Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);\r
-  }\r
-\r
-  VariableStoreHeader[VariableStoreTypeHob] = GetVariableStore (VariableStoreTypeHob, &StoreInfoForHob);\r
-  VariableStoreHeader[VariableStoreTypeNv]  = GetVariableStore (VariableStoreTypeNv, &StoreInfoForNv);\r
-\r
-  while (TRUE) {\r
-    //\r
-    // Switch from HOB to Non-Volatile.\r
-    //\r
-    while (!GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader)) {\r
-      //\r
-      // Find current storage index\r
-      //\r
-      for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {\r
-        if ((VariableStoreHeader[Type] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreHeader[Type]))) {\r
-          break;\r
-        }\r
-      }\r
-      ASSERT (Type < VariableStoreTypeMax);\r
-      //\r
-      // Switch to next storage\r
-      //\r
-      for (Type++; Type < VariableStoreTypeMax; Type++) {\r
-        if (VariableStoreHeader[Type] != NULL) {\r
-          break;\r
-        }\r
-      }\r
-      //\r
-      // Capture the case that \r
-      // 1. current storage is the last one, or\r
-      // 2. no further storage\r
-      //\r
-      if (Type == VariableStoreTypeMax) {\r
-        return EFI_NOT_FOUND;\r
-      }\r
-      Variable.StartPtr = GetStartPointer (VariableStoreHeader[Type]);\r
-      Variable.EndPtr   = GetEndPointer   (VariableStoreHeader[Type]);\r
-      Variable.CurrPtr  = Variable.StartPtr;\r
-      GetVariableStore (Type, &StoreInfo);\r
-    }\r
-\r
-    if (VariableHeader->State == VAR_ADDED || VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
-      if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
-        //\r
-        // If it is a IN_DELETED_TRANSITION variable,\r
-        // and there is also a same ADDED one at the same time,\r
-        // don't return it.\r
-        //\r
-        Status = FindVariableEx (\r
-                   &StoreInfo,\r
-                   GetVariableNamePtr (Variable.CurrPtr),\r
-                   &VariableHeader->VendorGuid,\r
-                   &VariablePtrTrack\r
-                   );\r
-        if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr != Variable.CurrPtr) {\r
-          Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);\r
-          continue;\r
-        }\r
-      }\r
-\r
-      //\r
-      // Don't return NV variable when HOB overrides it\r
-      //\r
-      if ((VariableStoreHeader[VariableStoreTypeHob] != NULL) && (VariableStoreHeader[VariableStoreTypeNv] != NULL) &&\r
-          (Variable.StartPtr == GetStartPointer (VariableStoreHeader[VariableStoreTypeNv]))\r
-         ) {\r
-        Status = FindVariableEx (\r
-                   &StoreInfoForHob,\r
-                   GetVariableNamePtr (Variable.CurrPtr),\r
-                   &VariableHeader->VendorGuid, \r
-                   &VariableInHob\r
-                   );\r
-        if (!EFI_ERROR (Status)) {\r
-          Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);\r
-          continue;\r
-        }\r
-      }\r
-\r
-      VarNameSize = NameSizeOfVariable (VariableHeader);\r
-      ASSERT (VarNameSize != 0);\r
-\r
-      if (VarNameSize <= *VariableNameSize) {\r
-        GetVariableNameOrData (&StoreInfo, (UINT8 *) GetVariableNamePtr (Variable.CurrPtr), VarNameSize, (UINT8 *) VariableName);\r
-\r
-        CopyMem (VariableGuid, &VariableHeader->VendorGuid, sizeof (EFI_GUID));\r
-\r
-        Status = EFI_SUCCESS;\r
-      } else {\r
-        Status = EFI_BUFFER_TOO_SMALL;\r
-      }\r
-\r
-      *VariableNameSize = VarNameSize;\r
-      //\r
-      // Variable is found\r
-      //\r
-      return Status;\r
-    } else {\r
-      Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);\r
-    }\r
-  }\r
-}\r
diff --git a/SecurityPkg/VariableAuthenticated/Pei/Variable.h b/SecurityPkg/VariableAuthenticated/Pei/Variable.h
deleted file mode 100644 (file)
index 7693522..0000000
+++ /dev/null
@@ -1,148 +0,0 @@
-/** @file\r
-  The internal header file includes the common header files, defines\r
-  internal structure and functions used by PeiVariable module.\r
-\r
-Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials \r
-are licensed and made available under the terms and conditions of the BSD License \r
-which accompanies this distribution.  The full text of the license may be found at \r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#ifndef _PEI_VARIABLE_H_\r
-#define _PEI_VARIABLE_H_\r
-\r
-#include <PiPei.h>\r
-#include <Ppi/ReadOnlyVariable2.h>\r
-\r
-#include <Library/DebugLib.h>\r
-#include <Library/PeimEntryPoint.h>\r
-#include <Library/HobLib.h>\r
-#include <Library/PcdLib.h>\r
-#include <Library/BaseMemoryLib.h>\r
-#include <Library/PeiServicesTablePointerLib.h>\r
-#include <Library/PeiServicesLib.h>\r
-\r
-#include <Guid/AuthenticatedVariableFormat.h>\r
-#include <Guid/VariableIndexTable.h>\r
-#include <Guid/SystemNvDataGuid.h>\r
-#include <Guid/FaultTolerantWrite.h>\r
-\r
-typedef enum {\r
-  VariableStoreTypeHob,\r
-  VariableStoreTypeNv,\r
-  VariableStoreTypeMax\r
-} VARIABLE_STORE_TYPE;\r
-\r
-typedef struct {\r
-  VARIABLE_STORE_HEADER                   *VariableStoreHeader;\r
-  VARIABLE_INDEX_TABLE                    *IndexTable;\r
-  //\r
-  // If it is not NULL, it means there may be an inconsecutive variable whose\r
-  // partial content is still in NV storage, but another partial content is backed up\r
-  // in spare block.\r
-  //\r
-  FAULT_TOLERANT_WRITE_LAST_WRITE_DATA    *FtwLastWriteData;\r
-} VARIABLE_STORE_INFO;\r
-\r
-//\r
-// Functions\r
-//\r
-/**\r
-  Provide the functionality of the variable services.\r
-  \r
-  @param  FileHandle  Handle of the file being invoked. \r
-                      Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile().\r
-  @param  PeiServices  General purpose services available to every PEIM.\r
-\r
-  @retval EFI_SUCCESS  If the interface could be successfully installed\r
-  @retval Others       Returned from PeiServicesInstallPpi()\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-PeimInitializeVariableServices (\r
-  IN       EFI_PEI_FILE_HANDLE       FileHandle,\r
-  IN CONST EFI_PEI_SERVICES          **PeiServices\r
-  );\r
-\r
-/**\r
-  This service retrieves a variable's value using its name and GUID.\r
-\r
-  Read the specified variable from the UEFI variable store. If the Data \r
-  buffer is too small to hold the contents of the variable, the error\r
-  EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer\r
-  size to obtain the data.\r
-\r
-  @param  This                  A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.\r
-  @param  VariableName          A pointer to a null-terminated string that is the variable's name.\r
-  @param  VariableGuid          A pointer to an EFI_GUID that is the variable's GUID. The combination of\r
-                                VariableGuid and VariableName must be unique.\r
-  @param  Attributes            If non-NULL, on return, points to the variable's attributes.\r
-  @param  DataSize              On entry, points to the size in bytes of the Data buffer.\r
-                                On return, points to the size of the data returned in Data.\r
-  @param  Data                  Points to the buffer which will hold the returned variable value.\r
-\r
-  @retval EFI_SUCCESS           The variable was read successfully.\r
-  @retval EFI_NOT_FOUND         The variable could not be found.\r
-  @retval EFI_BUFFER_TOO_SMALL  The DataSize is too small for the resulting data. \r
-                                DataSize is updated with the size required for \r
-                                the specified variable.\r
-  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.\r
-  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-PeiGetVariable (\r
-  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,\r
-  IN CONST  CHAR16                          *VariableName,\r
-  IN CONST  EFI_GUID                        *VariableGuid,\r
-  OUT       UINT32                          *Attributes,\r
-  IN OUT    UINTN                           *DataSize,\r
-  OUT       VOID                            *Data\r
-  );\r
-\r
-/**\r
-  Return the next variable name and GUID.\r
-\r
-  This function is called multiple times to retrieve the VariableName \r
-  and VariableGuid of all variables currently available in the system. \r
-  On each call, the previous results are passed into the interface, \r
-  and, on return, the interface returns the data for the next \r
-  interface. When the entire variable list has been returned, \r
-  EFI_NOT_FOUND is returned.\r
-\r
-  @param  This              A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.\r
-\r
-  @param  VariableNameSize  On entry, points to the size of the buffer pointed to by VariableName.\r
-  @param  VariableName      On entry, a pointer to a null-terminated string that is the variable's name.\r
-                            On return, points to the next variable's null-terminated name string.\r
-\r
-  @param  VariableGuid      On entry, a pointer to an UEFI _GUID that is the variable's GUID. \r
-                            On return, a pointer to the next variable's GUID.\r
-\r
-  @retval EFI_SUCCESS           The variable was read successfully.\r
-  @retval EFI_NOT_FOUND         The variable could not be found.\r
-  @retval EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the resulting\r
-                                data. VariableNameSize is updated with the size\r
-                                required for the specified variable.\r
-  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or\r
-                                VariableNameSize is NULL.\r
-  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-PeiGetNextVariableName (\r
-  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,\r
-  IN OUT UINTN                              *VariableNameSize,\r
-  IN OUT CHAR16                             *VariableName,\r
-  IN OUT EFI_GUID                           *VariableGuid\r
-  );\r
-\r
-#endif\r
diff --git a/SecurityPkg/VariableAuthenticated/Pei/VariablePei.inf b/SecurityPkg/VariableAuthenticated/Pei/VariablePei.inf
deleted file mode 100644 (file)
index fa0b5e9..0000000
+++ /dev/null
@@ -1,73 +0,0 @@
-## @file\r
-#  Implements ReadOnly Variable Services required by PEIM and installs PEI ReadOnly Varaiable2 PPI\r
-#  This module implements ReadOnly Variable Services required by PEIM and installs PEI ReadOnly Varaiable2 PPI.\r
-#\r
-# Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>\r
-# This program and the accompanying materials\r
-# are licensed and made available under the terms and conditions of the BSD License\r
-# which accompanies this distribution. The full text of the license may be found at\r
-# http://opensource.org/licenses/bsd-license.php\r
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-#\r
-##\r
-\r
-[Defines]\r
-  INF_VERSION                    = 0x00010005\r
-  BASE_NAME                      = PeiVariableAuth\r
-  MODULE_UNI_FILE                = PeiVariableAuth.uni\r
-  FILE_GUID                      = B1F7AF2F-2807-478c-A893-2BF4DDD1F62B\r
-  MODULE_TYPE                    = PEIM\r
-  VERSION_STRING                 = 1.0\r
-  ENTRY_POINT                    = PeimInitializeVariableServices\r
-\r
-#\r
-# The following information is for reference only and not required by the build tools.\r
-#\r
-#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC\r
-#\r
-\r
-[Sources]\r
-  Variable.c\r
-  Variable.h\r
-\r
-[Packages]\r
-  MdePkg/MdePkg.dec\r
-  MdeModulePkg/MdeModulePkg.dec\r
-  SecurityPkg/SecurityPkg.dec\r
-\r
-[LibraryClasses]\r
-  BaseMemoryLib\r
-  PcdLib\r
-  HobLib\r
-  PeimEntryPoint\r
-  DebugLib\r
-  PeiServicesTablePointerLib\r
-  PeiServicesLib\r
-\r
-[Guids]\r
-  ## CONSUMES             ## GUID # Variable store header\r
-  ## SOMETIMES_CONSUMES   ## HOB\r
-  gEfiAuthenticatedVariableGuid\r
-  ## SOMETIMES_PRODUCES   ## HOB\r
-  ## SOMETIMES_CONSUMES   ## HOB\r
-  gEfiVariableIndexTableGuid\r
-  gEfiSystemNvDataFvGuid            ## SOMETIMES_CONSUMES   ## GUID\r
-  gEdkiiFaultTolerantWriteGuid      ## SOMETIMES_CONSUMES   ## HOB\r
-\r
-[Ppis]\r
-  gEfiPeiReadOnlyVariable2PpiGuid   ## PRODUCES\r
-\r
-[Pcd]\r
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase      ## SOMETIMES_CONSUMES\r
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64    ## CONSUMES\r
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize      ## CONSUMES\r
-\r
-[Depex]\r
-  gEdkiiFaultTolerantWriteGuid\r
-\r
-# [BootMode]\r
-# RECOVERY_FULL             ## SOMETIMES_CONSUMES\r
-\r
-[UserExtensions.TianoCore."ExtraFiles"]\r
-  PeiVariableExtra.uni
\ No newline at end of file
diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.c b/SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.c
deleted file mode 100644 (file)
index 9599c8a..0000000
+++ /dev/null
@@ -1,2532 +0,0 @@
-/** @file\r
-  Implement authentication services for the authenticated variable\r
-  service in UEFI2.2.\r
-\r
-  Caution: This module requires additional review when modified.\r
-  This driver will have external input - variable data. It may be input in SMM mode.\r
-  This external input must be validated carefully to avoid security issue like\r
-  buffer overflow, integer overflow.\r
-  Variable attribute should also be checked to avoid authentication bypass.\r
-     The whole SMM authentication variable design relies on the integrity of flash part and SMM.\r
-  which is assumed to be protected by platform.  All variable code and metadata in flash/SMM Memory\r
-  may not be modified without authorization. If platform fails to protect these resources,\r
-  the authentication service provided in this driver will be broken, and the behavior is undefined.\r
-\r
-  ProcessVarWithPk(), ProcessVarWithKek() and ProcessVariable() are the function to do\r
-  variable authentication.\r
-\r
-  VerifyTimeBasedPayload() and VerifyCounterBasedPayload() are sub function to do verification.\r
-  They will do basic validation for authentication data structure, then call crypto library\r
-  to verify the signature.\r
-\r
-Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials\r
-are licensed and made available under the terms and conditions of the BSD License\r
-which accompanies this distribution.  The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#include "Variable.h"\r
-#include "AuthService.h"\r
-\r
-///\r
-/// Global database array for scratch\r
-///\r
-UINT8    *mPubKeyStore;\r
-UINT32   mPubKeyNumber;\r
-UINT32   mMaxKeyNumber;\r
-UINT32   mMaxKeyDbSize;\r
-UINT8    *mCertDbStore;\r
-UINT32   mMaxCertDbSize;\r
-UINT32   mPlatformMode;\r
-UINT8    mVendorKeyState;\r
-\r
-EFI_GUID mSignatureSupport[] = {EFI_CERT_SHA1_GUID, EFI_CERT_SHA256_GUID, EFI_CERT_RSA2048_GUID, EFI_CERT_X509_GUID};\r
-//\r
-// Public Exponent of RSA Key.\r
-//\r
-CONST UINT8 mRsaE[] = { 0x01, 0x00, 0x01 };\r
-//\r
-// Hash context pointer\r
-//\r
-VOID  *mHashCtx = NULL;\r
-\r
-//\r
-// Requirement for different signature type which have been defined in UEFI spec.\r
-// These data are used to peform SignatureList format check while setting PK/KEK variable.\r
-//\r
-EFI_SIGNATURE_ITEM mSupportSigItem[] = {\r
-//{SigType,                       SigHeaderSize,   SigDataSize  }\r
-  {EFI_CERT_SHA256_GUID,          0,               32           },\r
-  {EFI_CERT_RSA2048_GUID,         0,               256          },\r
-  {EFI_CERT_RSA2048_SHA256_GUID,  0,               256          },\r
-  {EFI_CERT_SHA1_GUID,            0,               20           },\r
-  {EFI_CERT_RSA2048_SHA1_GUID,    0,               256          },\r
-  {EFI_CERT_X509_GUID,            0,               ((UINT32) ~0)},\r
-  {EFI_CERT_SHA224_GUID,          0,               28           },\r
-  {EFI_CERT_SHA384_GUID,          0,               48           },\r
-  {EFI_CERT_SHA512_GUID,          0,               64           },\r
-  {EFI_CERT_X509_SHA256_GUID,     0,               48           },\r
-  {EFI_CERT_X509_SHA384_GUID,     0,               64           },\r
-  {EFI_CERT_X509_SHA512_GUID,     0,               80           }\r
-};\r
-\r
-/**\r
-  Determine whether this operation needs a physical present user.\r
-\r
-  @param[in]      VariableName            Name of the Variable.\r
-  @param[in]      VendorGuid              GUID of the Variable.\r
-\r
-  @retval TRUE      This variable is protected, only a physical present user could set this variable.\r
-  @retval FALSE     This variable is not protected.\r
-\r
-**/\r
-BOOLEAN\r
-NeedPhysicallyPresent(\r
-  IN     CHAR16         *VariableName,\r
-  IN     EFI_GUID       *VendorGuid\r
-  )\r
-{\r
-  if ((CompareGuid (VendorGuid, &gEfiSecureBootEnableDisableGuid) && (StrCmp (VariableName, EFI_SECURE_BOOT_ENABLE_NAME) == 0))\r
-    || (CompareGuid (VendorGuid, &gEfiCustomModeEnableGuid) && (StrCmp (VariableName, EFI_CUSTOM_MODE_NAME) == 0))) {\r
-    return TRUE;\r
-  }\r
-\r
-  return FALSE;\r
-}\r
-\r
-/**\r
-  Determine whether the platform is operating in Custom Secure Boot mode.\r
-\r
-  @retval TRUE           The platform is operating in Custom mode.\r
-  @retval FALSE          The platform is operating in Standard mode.\r
-\r
-**/\r
-BOOLEAN\r
-InCustomMode (\r
-  VOID\r
-  )\r
-{\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-\r
-  FindVariable (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  if (Variable.CurrPtr != NULL && *(GetVariableDataPtr (Variable.CurrPtr)) == CUSTOM_SECURE_BOOT_MODE) {\r
-    return TRUE;\r
-  }\r
-\r
-  return FALSE;\r
-}\r
-\r
-/**\r
-  Initializes for authenticated varibale service.\r
-\r
-  @param[in] MaxAuthVariableSize    Reflect the overhead associated with the saving\r
-                                    of a single EFI authenticated variable with the exception\r
-                                    of the overhead associated with the length\r
-                                    of the string name of the EFI variable.\r
-\r
-  @retval EFI_SUCCESS           Function successfully executed.\r
-  @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resources.\r
-\r
-**/\r
-EFI_STATUS\r
-AutenticatedVariableServiceInitialize (\r
-  IN UINTN      MaxAuthVariableSize\r
-  )\r
-{\r
-  EFI_STATUS              Status;\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-  VARIABLE_POINTER_TRACK  PkVariable;\r
-  UINT8                   VarValue;\r
-  UINT32                  VarAttr;\r
-  UINT8                   *Data;\r
-  UINTN                   DataSize;\r
-  UINTN                   CtxSize;\r
-  UINT8                   SecureBootMode;\r
-  UINT8                   SecureBootEnable;\r
-  UINT8                   CustomMode;\r
-  UINT32                  ListSize;\r
-\r
-  //\r
-  // Initialize hash context.\r
-  //\r
-  CtxSize   = Sha256GetContextSize ();\r
-  mHashCtx  = AllocateRuntimePool (CtxSize);\r
-  if (mHashCtx == NULL) {\r
-    return EFI_OUT_OF_RESOURCES;\r
-  }\r
-\r
-  //\r
-  // Reserve runtime buffer for public key database. The size excludes variable header and name size.\r
-  //\r
-  mMaxKeyDbSize = (UINT32) (MaxAuthVariableSize - sizeof (AUTHVAR_KEYDB_NAME));\r
-  mMaxKeyNumber = mMaxKeyDbSize / EFI_CERT_TYPE_RSA2048_SIZE;\r
-  mPubKeyStore  = AllocateRuntimePool (mMaxKeyDbSize);\r
-  if (mPubKeyStore == NULL) {\r
-    return EFI_OUT_OF_RESOURCES;\r
-  }\r
-\r
-  //\r
-  // Reserve runtime buffer for certificate database. The size excludes variable header and name size.\r
-  //\r
-  mMaxCertDbSize = (UINT32) (MaxAuthVariableSize - sizeof (EFI_CERT_DB_NAME));\r
-  mCertDbStore   = AllocateRuntimePool (mMaxCertDbSize);\r
-  if (mCertDbStore == NULL) {\r
-    return EFI_OUT_OF_RESOURCES;\r
-  }\r
-\r
-  //\r
-  // Check "AuthVarKeyDatabase" variable's existence.\r
-  // If it doesn't exist, create a new one with initial value of 0 and EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS set.\r
-  //\r
-  Status = FindVariable (\r
-             AUTHVAR_KEYDB_NAME,\r
-             &gEfiAuthenticatedVariableGuid,\r
-             &Variable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-\r
-  if (Variable.CurrPtr == NULL) {\r
-    VarAttr       = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS;\r
-    VarValue      = 0;\r
-    mPubKeyNumber = 0;\r
-    Status        = UpdateVariable (\r
-                      AUTHVAR_KEYDB_NAME,\r
-                      &gEfiAuthenticatedVariableGuid,\r
-                      &VarValue,\r
-                      sizeof(UINT8),\r
-                      VarAttr,\r
-                      0,\r
-                      0,\r
-                      &Variable,\r
-                      NULL\r
-                      );\r
-    if (EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-  } else {\r
-    //\r
-    // Load database in global variable for cache.\r
-    //\r
-    DataSize  = DataSizeOfVariable (Variable.CurrPtr);\r
-    Data      = GetVariableDataPtr (Variable.CurrPtr);\r
-    ASSERT ((DataSize != 0) && (Data != NULL));\r
-    //\r
-    // "AuthVarKeyDatabase" is an internal variable. Its DataSize is always ensured not to exceed mPubKeyStore buffer size(See definition before)\r
-    //  Therefore, there is no memory overflow in underlying CopyMem.\r
-    //\r
-    CopyMem (mPubKeyStore, (UINT8 *) Data, DataSize);\r
-    mPubKeyNumber = (UINT32) (DataSize / EFI_CERT_TYPE_RSA2048_SIZE);\r
-  }\r
-\r
-  FindVariable (EFI_PLATFORM_KEY_NAME, &gEfiGlobalVariableGuid, &PkVariable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  if (PkVariable.CurrPtr == NULL) {\r
-    DEBUG ((EFI_D_INFO, "Variable %s does not exist.\n", EFI_PLATFORM_KEY_NAME));\r
-  } else {\r
-    DEBUG ((EFI_D_INFO, "Variable %s exists.\n", EFI_PLATFORM_KEY_NAME));\r
-  }\r
-\r
-  //\r
-  // Create "SetupMode" variable with BS+RT attribute set.\r
-  //\r
-  FindVariable (EFI_SETUP_MODE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  if (PkVariable.CurrPtr == NULL) {\r
-    mPlatformMode = SETUP_MODE;\r
-  } else {\r
-    mPlatformMode = USER_MODE;\r
-  }\r
-  Status = UpdateVariable (\r
-             EFI_SETUP_MODE_NAME,\r
-             &gEfiGlobalVariableGuid,\r
-             &mPlatformMode,\r
-             sizeof(UINT8),\r
-             EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
-             0,\r
-             0,\r
-             &Variable,\r
-             NULL\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // Create "SignatureSupport" variable with BS+RT attribute set.\r
-  //\r
-  FindVariable (EFI_SIGNATURE_SUPPORT_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  Status  = UpdateVariable (\r
-              EFI_SIGNATURE_SUPPORT_NAME,\r
-              &gEfiGlobalVariableGuid,\r
-              mSignatureSupport,\r
-              sizeof(mSignatureSupport),\r
-              EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
-              0,\r
-              0,\r
-              &Variable,\r
-              NULL\r
-              );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // If "SecureBootEnable" variable exists, then update "SecureBoot" variable.\r
-  // If "SecureBootEnable" variable is SECURE_BOOT_ENABLE and in USER_MODE, Set "SecureBoot" variable to SECURE_BOOT_MODE_ENABLE.\r
-  // If "SecureBootEnable" variable is SECURE_BOOT_DISABLE, Set "SecureBoot" variable to SECURE_BOOT_MODE_DISABLE.\r
-  //\r
-  SecureBootEnable = SECURE_BOOT_DISABLE;\r
-  FindVariable (EFI_SECURE_BOOT_ENABLE_NAME, &gEfiSecureBootEnableDisableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  if (Variable.CurrPtr != NULL) {\r
-    if (mPlatformMode == SETUP_MODE){\r
-      //\r
-      // PK is cleared in runtime. "SecureBootMode" is not updated before reboot \r
-      // Delete "SecureBootMode" in SetupMode\r
-      //\r
-      Status = UpdateVariable (\r
-                 EFI_SECURE_BOOT_ENABLE_NAME,\r
-                 &gEfiSecureBootEnableDisableGuid,\r
-                 &SecureBootEnable,\r
-                 0,\r
-                 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
-                 0,\r
-                 0,\r
-                 &Variable,\r
-                 NULL\r
-                 );\r
-    } else {\r
-      SecureBootEnable = *(GetVariableDataPtr (Variable.CurrPtr));\r
-    }\r
-  } else if (mPlatformMode == USER_MODE) {\r
-    //\r
-    // "SecureBootEnable" not exist, initialize it in USER_MODE.\r
-    //\r
-    SecureBootEnable = SECURE_BOOT_ENABLE;\r
-    Status = UpdateVariable (\r
-               EFI_SECURE_BOOT_ENABLE_NAME,\r
-               &gEfiSecureBootEnableDisableGuid,\r
-               &SecureBootEnable,\r
-               sizeof (UINT8),\r
-               EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
-               0,\r
-               0,\r
-               &Variable,\r
-               NULL\r
-               );\r
-    if (EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-  }\r
-\r
-  //\r
-  // Create "SecureBoot" variable with BS+RT attribute set.\r
-  //\r
-  if (SecureBootEnable == SECURE_BOOT_ENABLE && mPlatformMode == USER_MODE) {\r
-    SecureBootMode = SECURE_BOOT_MODE_ENABLE;\r
-  } else {\r
-    SecureBootMode = SECURE_BOOT_MODE_DISABLE;\r
-  }\r
-  FindVariable (EFI_SECURE_BOOT_MODE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  Status = UpdateVariable (\r
-             EFI_SECURE_BOOT_MODE_NAME,\r
-             &gEfiGlobalVariableGuid,\r
-             &SecureBootMode,\r
-             sizeof (UINT8),\r
-             EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
-             0,\r
-             0,\r
-             &Variable,\r
-             NULL\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  DEBUG ((EFI_D_INFO, "Variable %s is %x\n", EFI_SETUP_MODE_NAME, mPlatformMode));\r
-  DEBUG ((EFI_D_INFO, "Variable %s is %x\n", EFI_SECURE_BOOT_MODE_NAME, SecureBootMode));\r
-  DEBUG ((EFI_D_INFO, "Variable %s is %x\n", EFI_SECURE_BOOT_ENABLE_NAME, SecureBootEnable));\r
-\r
-  //\r
-  // Initialize "CustomMode" in STANDARD_SECURE_BOOT_MODE state.\r
-  //\r
-  FindVariable (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  CustomMode = STANDARD_SECURE_BOOT_MODE;\r
-  Status = UpdateVariable (\r
-             EFI_CUSTOM_MODE_NAME,\r
-             &gEfiCustomModeEnableGuid,\r
-             &CustomMode,\r
-             sizeof (UINT8),\r
-             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
-             0,\r
-             0,\r
-             &Variable,\r
-             NULL\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  DEBUG ((EFI_D_INFO, "Variable %s is %x\n", EFI_CUSTOM_MODE_NAME, CustomMode));\r
-\r
-  //\r
-  // Check "certdb" variable's existence.\r
-  // If it doesn't exist, then create a new one with\r
-  // EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set.\r
-  //\r
-  Status = FindVariable (\r
-             EFI_CERT_DB_NAME,\r
-             &gEfiCertDbGuid,\r
-             &Variable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-\r
-  if (Variable.CurrPtr == NULL) {\r
-    VarAttr  = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
-    ListSize = sizeof (UINT32);\r
-    Status   = UpdateVariable (\r
-                 EFI_CERT_DB_NAME,\r
-                 &gEfiCertDbGuid,\r
-                 &ListSize,\r
-                 sizeof (UINT32),\r
-                 VarAttr,\r
-                 0,\r
-                 0,\r
-                 &Variable,\r
-                 NULL\r
-                 );\r
-    if (EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-  }\r
-\r
-  //\r
-  // Check "VendorKeysNv" variable's existence and create "VendorKeys" variable accordingly.\r
-  //\r
-  FindVariable (EFI_VENDOR_KEYS_NV_VARIABLE_NAME, &gEfiVendorKeysNvGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  if (Variable.CurrPtr != NULL) {\r
-    mVendorKeyState = *(GetVariableDataPtr (Variable.CurrPtr));\r
-  } else {\r
-    //\r
-    // "VendorKeysNv" not exist, initialize it in VENDOR_KEYS_VALID state.\r
-    //\r
-    mVendorKeyState = VENDOR_KEYS_VALID;\r
-    Status = UpdateVariable (\r
-               EFI_VENDOR_KEYS_NV_VARIABLE_NAME,\r
-               &gEfiVendorKeysNvGuid,\r
-               &mVendorKeyState,\r
-               sizeof (UINT8),\r
-               EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS,\r
-               0,\r
-               0,\r
-               &Variable,\r
-               NULL\r
-               );\r
-    if (EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-  }\r
-\r
-  //\r
-  // Create "VendorKeys" variable with BS+RT attribute set.\r
-  //\r
-  FindVariable (EFI_VENDOR_KEYS_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  Status = UpdateVariable (\r
-             EFI_VENDOR_KEYS_VARIABLE_NAME,\r
-             &gEfiGlobalVariableGuid,\r
-             &mVendorKeyState,\r
-             sizeof (UINT8),\r
-             EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
-             0,\r
-             0,\r
-             &Variable,\r
-             NULL\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  DEBUG ((EFI_D_INFO, "Variable %s is %x\n", EFI_VENDOR_KEYS_VARIABLE_NAME, mVendorKeyState));\r
-\r
-  return Status;\r
-}\r
-\r
-/**\r
-  Add public key in store and return its index.\r
-\r
-  @param[in]  PubKey                  Input pointer to Public Key data\r
-  @param[in]  VariableDataEntry       The variable data entry\r
-\r
-  @return                             Index of new added item\r
-\r
-**/\r
-UINT32\r
-AddPubKeyInStore (\r
-  IN  UINT8                        *PubKey,\r
-  IN  VARIABLE_ENTRY_CONSISTENCY   *VariableDataEntry\r
-  )\r
-{\r
-  EFI_STATUS                       Status;\r
-  BOOLEAN                          IsFound;\r
-  UINT32                           Index;\r
-  VARIABLE_POINTER_TRACK           Variable;\r
-  UINT8                            *Ptr;\r
-  UINT8                            *Data;\r
-  UINTN                            DataSize;\r
-  VARIABLE_ENTRY_CONSISTENCY       PublicKeyEntry;\r
-  UINT32                           Attributes;\r
-\r
-  if (PubKey == NULL) {\r
-    return 0;\r
-  }\r
-\r
-  Status = FindVariable (\r
-             AUTHVAR_KEYDB_NAME,\r
-             &gEfiAuthenticatedVariableGuid,\r
-             &Variable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    DEBUG ((EFI_D_ERROR, "Get public key database variable failure, Status = %r\n", Status));\r
-    return 0;\r
-  }\r
-\r
-  //\r
-  // Check whether the public key entry does exist.\r
-  //\r
-  IsFound = FALSE;\r
-  for (Ptr = mPubKeyStore, Index = 1; Index <= mPubKeyNumber; Index++) {\r
-    if (CompareMem (Ptr, PubKey, EFI_CERT_TYPE_RSA2048_SIZE) == 0) {\r
-      IsFound = TRUE;\r
-      break;\r
-    }\r
-    Ptr += EFI_CERT_TYPE_RSA2048_SIZE;\r
-  }\r
-\r
-  if (!IsFound) {\r
-    //\r
-    // Add public key in database.\r
-    //\r
-    if (mPubKeyNumber == mMaxKeyNumber) {\r
-      //\r
-      // Public key dadatase is full, try to reclaim invalid key.\r
-      //\r
-      if (AtRuntime ()) {\r
-        //\r
-        // NV storage can't reclaim at runtime.\r
-        //\r
-        return 0;\r
-      }\r
-\r
-      Status = Reclaim (\r
-                 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,\r
-                 &mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
-                 FALSE,\r
-                 NULL,\r
-                 NULL,\r
-                 0,\r
-                 TRUE\r
-                 );\r
-      if (EFI_ERROR (Status)) {\r
-        return 0;\r
-      }\r
-\r
-      Status = FindVariable (\r
-                 AUTHVAR_KEYDB_NAME,\r
-                 &gEfiAuthenticatedVariableGuid,\r
-                 &Variable,\r
-                 &mVariableModuleGlobal->VariableGlobal,\r
-                 FALSE\r
-                 );\r
-      if (EFI_ERROR (Status)) {\r
-        DEBUG ((EFI_D_ERROR, "Get public key database variable failure, Status = %r\n", Status));\r
-        return 0;\r
-      }\r
-\r
-      DataSize  = DataSizeOfVariable (Variable.CurrPtr);\r
-      Data      = GetVariableDataPtr (Variable.CurrPtr);\r
-      ASSERT ((DataSize != 0) && (Data != NULL));\r
-      //\r
-      // "AuthVarKeyDatabase" is an internal used variable. Its DataSize is always ensured not to exceed mPubKeyStore buffer size(See definition before)\r
-      //  Therefore, there is no memory overflow in underlying CopyMem.\r
-      //\r
-      CopyMem (mPubKeyStore, (UINT8 *) Data, DataSize);\r
-      mPubKeyNumber = (UINT32) (DataSize / EFI_CERT_TYPE_RSA2048_SIZE);\r
-\r
-      if (mPubKeyNumber == mMaxKeyNumber) {\r
-        return 0;\r
-      }\r
-    }\r
-\r
-    //\r
-    // Check the variable space for both public key and variable data.\r
-    //\r
-    PublicKeyEntry.VariableSize = (mPubKeyNumber + 1) * EFI_CERT_TYPE_RSA2048_SIZE;\r
-    PublicKeyEntry.Guid         = &gEfiAuthenticatedVariableGuid;\r
-    PublicKeyEntry.Name         = AUTHVAR_KEYDB_NAME;\r
-    Attributes = VARIABLE_ATTRIBUTE_NV_BS_RT | EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS;\r
-\r
-    if (!CheckRemainingSpaceForConsistency (Attributes, &PublicKeyEntry, VariableDataEntry, NULL)) {\r
-      //\r
-      // No enough variable space.\r
-      //\r
-      return 0;\r
-    }\r
-\r
-    CopyMem (mPubKeyStore + mPubKeyNumber * EFI_CERT_TYPE_RSA2048_SIZE, PubKey, EFI_CERT_TYPE_RSA2048_SIZE);\r
-    Index = ++mPubKeyNumber;\r
-    //\r
-    // Update public key database variable.\r
-    //\r
-    Status = UpdateVariable (\r
-               AUTHVAR_KEYDB_NAME,\r
-               &gEfiAuthenticatedVariableGuid,\r
-               mPubKeyStore,\r
-               mPubKeyNumber * EFI_CERT_TYPE_RSA2048_SIZE,\r
-               Attributes,\r
-               0,\r
-               0,\r
-               &Variable,\r
-               NULL\r
-               );\r
-    if (EFI_ERROR (Status)) {\r
-      DEBUG ((EFI_D_ERROR, "Update public key database variable failure, Status = %r\n", Status));\r
-      return 0;\r
-    }\r
-  }\r
-\r
-  return Index;\r
-}\r
-\r
-/**\r
-  Verify data payload with AuthInfo in EFI_CERT_TYPE_RSA2048_SHA256_GUID type.\r
-  Follow the steps in UEFI2.2.\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-\r
-  @param[in]      Data                    Pointer to data with AuthInfo.\r
-  @param[in]      DataSize                Size of Data.\r
-  @param[in]      PubKey                  Public key used for verification.\r
-\r
-  @retval EFI_INVALID_PARAMETER       Invalid parameter.\r
-  @retval EFI_SECURITY_VIOLATION      If authentication failed.\r
-  @retval EFI_SUCCESS                 Authentication successful.\r
-\r
-**/\r
-EFI_STATUS\r
-VerifyCounterBasedPayload (\r
-  IN     UINT8          *Data,\r
-  IN     UINTN          DataSize,\r
-  IN     UINT8          *PubKey\r
-  )\r
-{\r
-  BOOLEAN                         Status;\r
-  EFI_VARIABLE_AUTHENTICATION     *CertData;\r
-  EFI_CERT_BLOCK_RSA_2048_SHA256  *CertBlock;\r
-  UINT8                           Digest[SHA256_DIGEST_SIZE];\r
-  VOID                            *Rsa;\r
-  UINTN                           PayloadSize;\r
-\r
-  PayloadSize = DataSize - AUTHINFO_SIZE;\r
-  Rsa         = NULL;\r
-  CertData    = NULL;\r
-  CertBlock   = NULL;\r
-\r
-  if (Data == NULL || PubKey == NULL) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  CertData  = (EFI_VARIABLE_AUTHENTICATION *) Data;\r
-  CertBlock = (EFI_CERT_BLOCK_RSA_2048_SHA256 *) (CertData->AuthInfo.CertData);\r
-\r
-  //\r
-  // wCertificateType should be WIN_CERT_TYPE_EFI_GUID.\r
-  // Cert type should be EFI_CERT_TYPE_RSA2048_SHA256_GUID.\r
-  //\r
-  if ((CertData->AuthInfo.Hdr.wCertificateType != WIN_CERT_TYPE_EFI_GUID) ||\r
-      !CompareGuid (&CertData->AuthInfo.CertType, &gEfiCertTypeRsa2048Sha256Guid)\r
-        ) {\r
-    //\r
-    // Invalid AuthInfo type, return EFI_SECURITY_VIOLATION.\r
-    //\r
-    return EFI_SECURITY_VIOLATION;\r
-  }\r
-  //\r
-  // Hash data payload with SHA256.\r
-  //\r
-  ZeroMem (Digest, SHA256_DIGEST_SIZE);\r
-  Status  = Sha256Init (mHashCtx);\r
-  if (!Status) {\r
-    goto Done;\r
-  }\r
-  Status  = Sha256Update (mHashCtx, Data + AUTHINFO_SIZE, PayloadSize);\r
-  if (!Status) {\r
-    goto Done;\r
-  }\r
-  //\r
-  // Hash Size.\r
-  //\r
-  Status  = Sha256Update (mHashCtx, &PayloadSize, sizeof (UINTN));\r
-  if (!Status) {\r
-    goto Done;\r
-  }\r
-  //\r
-  // Hash Monotonic Count.\r
-  //\r
-  Status  = Sha256Update (mHashCtx, &CertData->MonotonicCount, sizeof (UINT64));\r
-  if (!Status) {\r
-    goto Done;\r
-  }\r
-  Status  = Sha256Final (mHashCtx, Digest);\r
-  if (!Status) {\r
-    goto Done;\r
-  }\r
-  //\r
-  // Generate & Initialize RSA Context.\r
-  //\r
-  Rsa = RsaNew ();\r
-  ASSERT (Rsa != NULL);\r
-  //\r
-  // Set RSA Key Components.\r
-  // NOTE: Only N and E are needed to be set as RSA public key for signature verification.\r
-  //\r
-  Status = RsaSetKey (Rsa, RsaKeyN, PubKey, EFI_CERT_TYPE_RSA2048_SIZE);\r
-  if (!Status) {\r
-    goto Done;\r
-  }\r
-  Status = RsaSetKey (Rsa, RsaKeyE, mRsaE, sizeof (mRsaE));\r
-  if (!Status) {\r
-    goto Done;\r
-  }\r
-  //\r
-  // Verify the signature.\r
-  //\r
-  Status = RsaPkcs1Verify (\r
-             Rsa,\r
-             Digest,\r
-             SHA256_DIGEST_SIZE,\r
-             CertBlock->Signature,\r
-             EFI_CERT_TYPE_RSA2048_SHA256_SIZE\r
-             );\r
-\r
-Done:\r
-  if (Rsa != NULL) {\r
-    RsaFree (Rsa);\r
-  }\r
-  if (Status) {\r
-    return EFI_SUCCESS;\r
-  } else {\r
-    return EFI_SECURITY_VIOLATION;\r
-  }\r
-}\r
-\r
-/**\r
-  Update platform mode.\r
-\r
-  @param[in]      Mode                    SETUP_MODE or USER_MODE.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid parameter.\r
-  @return EFI_SUCCESS                     Update platform mode successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-UpdatePlatformMode (\r
-  IN  UINT32                    Mode\r
-  )\r
-{\r
-  EFI_STATUS              Status;\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-  UINT8                   SecureBootMode;\r
-  UINT8                   SecureBootEnable;\r
-  UINTN                   VariableDataSize;\r
-\r
-  Status = FindVariable (\r
-             EFI_SETUP_MODE_NAME,\r
-             &gEfiGlobalVariableGuid,\r
-             &Variable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // Update the value of SetupMode variable by a simple mem copy, this could avoid possible\r
-  // variable storage reclaim at runtime.\r
-  //\r
-  mPlatformMode = (UINT8) Mode;\r
-  CopyMem (GetVariableDataPtr (Variable.CurrPtr), &mPlatformMode, sizeof(UINT8));\r
-\r
-  if (AtRuntime ()) {\r
-    //\r
-    // SecureBoot Variable indicates whether the platform firmware is operating\r
-    // in Secure boot mode (1) or not (0), so we should not change SecureBoot\r
-    // Variable in runtime.\r
-    //\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // Check "SecureBoot" variable's existence.\r
-  // If it doesn't exist, firmware has no capability to perform driver signing verification,\r
-  // then set "SecureBoot" to 0.\r
-  //\r
-  Status = FindVariable (\r
-             EFI_SECURE_BOOT_MODE_NAME,\r
-             &gEfiGlobalVariableGuid,\r
-             &Variable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-  //\r
-  // If "SecureBoot" variable exists, then check "SetupMode" variable update.\r
-  // If "SetupMode" variable is USER_MODE, "SecureBoot" variable is set to 1.\r
-  // If "SetupMode" variable is SETUP_MODE, "SecureBoot" variable is set to 0.\r
-  //\r
-  if (Variable.CurrPtr == NULL) {\r
-    SecureBootMode = SECURE_BOOT_MODE_DISABLE;\r
-  } else {\r
-    if (mPlatformMode == USER_MODE) {\r
-      SecureBootMode = SECURE_BOOT_MODE_ENABLE;\r
-    } else if (mPlatformMode == SETUP_MODE) {\r
-      SecureBootMode = SECURE_BOOT_MODE_DISABLE;\r
-    } else {\r
-      return EFI_NOT_FOUND;\r
-    }\r
-  }\r
-\r
-  Status  = UpdateVariable (\r
-              EFI_SECURE_BOOT_MODE_NAME,\r
-              &gEfiGlobalVariableGuid,\r
-              &SecureBootMode,\r
-              sizeof(UINT8),\r
-              EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
-              0,\r
-              0,\r
-              &Variable,\r
-              NULL\r
-              );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // Check "SecureBootEnable" variable's existence. It can enable/disable secure boot feature.\r
-  //\r
-  Status = FindVariable (\r
-             EFI_SECURE_BOOT_ENABLE_NAME,\r
-             &gEfiSecureBootEnableDisableGuid,\r
-             &Variable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-\r
-  if (SecureBootMode == SECURE_BOOT_MODE_ENABLE) {\r
-    //\r
-    // Create the "SecureBootEnable" variable as secure boot is enabled.\r
-    //\r
-    SecureBootEnable = SECURE_BOOT_ENABLE;\r
-    VariableDataSize = sizeof (SecureBootEnable);\r
-  } else {\r
-    //\r
-    // Delete the "SecureBootEnable" variable if this variable exist as "SecureBoot"\r
-    // variable is not in secure boot state.\r
-    //\r
-    if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {\r
-      return EFI_SUCCESS;\r
-    }\r
-    SecureBootEnable = SECURE_BOOT_DISABLE;\r
-    VariableDataSize = 0;\r
-  }\r
-\r
-  Status = UpdateVariable (\r
-             EFI_SECURE_BOOT_ENABLE_NAME,\r
-             &gEfiSecureBootEnableDisableGuid,\r
-             &SecureBootEnable,\r
-             VariableDataSize,\r
-             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
-             0,\r
-             0,\r
-             &Variable,\r
-             NULL\r
-             );\r
-  return Status;\r
-}\r
-\r
-/**\r
-  Check input data form to make sure it is a valid EFI_SIGNATURE_LIST for PK/KEK/db/dbx/dbt variable.\r
-\r
-  @param[in]  VariableName                Name of Variable to be check.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-  @param[in]  Data                        Point to the variable data to be checked.\r
-  @param[in]  DataSize                    Size of Data.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid signature list format.\r
-  @return EFI_SUCCESS                     Passed signature list format check successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-CheckSignatureListFormat(\r
-  IN  CHAR16                    *VariableName,\r
-  IN  EFI_GUID                  *VendorGuid,\r
-  IN  VOID                      *Data,\r
-  IN  UINTN                     DataSize\r
-  )\r
-{\r
-  EFI_SIGNATURE_LIST     *SigList;\r
-  UINTN                  SigDataSize;\r
-  UINT32                 Index;\r
-  UINT32                 SigCount;\r
-  BOOLEAN                IsPk;\r
-  VOID                   *RsaContext;\r
-  EFI_SIGNATURE_DATA     *CertData;\r
-  UINTN                  CertLen;\r
-\r
-  if (DataSize == 0) {\r
-    return EFI_SUCCESS;\r
-  }\r
-\r
-  ASSERT (VariableName != NULL && VendorGuid != NULL && Data != NULL);\r
-\r
-  if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_PLATFORM_KEY_NAME) == 0)){\r
-    IsPk = TRUE;\r
-  } else if ((CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_KEY_EXCHANGE_KEY_NAME) == 0)) ||\r
-             (CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid) &&\r
-             ((StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE) == 0) || (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE1) == 0) ||\r
-              (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE2) == 0)))) {\r
-    IsPk = FALSE;\r
-  } else {\r
-    return EFI_SUCCESS;\r
-  }\r
-\r
-  SigCount = 0;\r
-  SigList  = (EFI_SIGNATURE_LIST *) Data;\r
-  SigDataSize  = DataSize;\r
-  RsaContext = NULL;\r
-\r
-  //\r
-  // Walk throuth the input signature list and check the data format.\r
-  // If any signature is incorrectly formed, the whole check will fail.\r
-  //\r
-  while ((SigDataSize > 0) && (SigDataSize >= SigList->SignatureListSize)) {\r
-    for (Index = 0; Index < (sizeof (mSupportSigItem) / sizeof (EFI_SIGNATURE_ITEM)); Index++ ) {\r
-      if (CompareGuid (&SigList->SignatureType, &mSupportSigItem[Index].SigType)) {\r
-        //\r
-        // The value of SignatureSize should always be 16 (size of SignatureOwner\r
-        // component) add the data length according to signature type.\r
-        //\r
-        if (mSupportSigItem[Index].SigDataSize != ((UINT32) ~0) &&\r
-          (SigList->SignatureSize - sizeof (EFI_GUID)) != mSupportSigItem[Index].SigDataSize) {\r
-          return EFI_INVALID_PARAMETER;\r
-        }\r
-        if (mSupportSigItem[Index].SigHeaderSize != ((UINTN) ~0) &&\r
-          SigList->SignatureHeaderSize != mSupportSigItem[Index].SigHeaderSize) {\r
-          return EFI_INVALID_PARAMETER;\r
-        }\r
-        break;\r
-      }\r
-    }\r
-\r
-    if (Index == (sizeof (mSupportSigItem) / sizeof (EFI_SIGNATURE_ITEM))) {\r
-      //\r
-      // Undefined signature type.\r
-      //\r
-      return EFI_INVALID_PARAMETER;\r
-    }\r
-\r
-    if (CompareGuid (&SigList->SignatureType, &gEfiCertX509Guid)) {\r
-      //\r
-      // Try to retrieve the RSA public key from the X.509 certificate.\r
-      // If this operation fails, it's not a valid certificate.\r
-      //\r
-      RsaContext = RsaNew ();\r
-      if (RsaContext == NULL) {\r
-        return EFI_INVALID_PARAMETER;\r
-      }\r
-      CertData = (EFI_SIGNATURE_DATA *) ((UINT8 *) SigList + sizeof (EFI_SIGNATURE_LIST) + SigList->SignatureHeaderSize);\r
-      CertLen = SigList->SignatureSize - sizeof (EFI_GUID);\r
-      if (!RsaGetPublicKeyFromX509 (CertData->SignatureData, CertLen, &RsaContext)) {\r
-        RsaFree (RsaContext);\r
-        return EFI_INVALID_PARAMETER;\r
-      }\r
-      RsaFree (RsaContext);\r
-    }\r
-\r
-    if ((SigList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - SigList->SignatureHeaderSize) % SigList->SignatureSize != 0) {\r
-      return EFI_INVALID_PARAMETER;\r
-    }\r
-    SigCount += (SigList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - SigList->SignatureHeaderSize) / SigList->SignatureSize;\r
-\r
-    SigDataSize -= SigList->SignatureListSize;\r
-    SigList = (EFI_SIGNATURE_LIST *) ((UINT8 *) SigList + SigList->SignatureListSize);\r
-  }\r
-\r
-  if (((UINTN) SigList - (UINTN) Data) != DataSize) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  if (IsPk && SigCount > 1) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Update "VendorKeys" variable to record the out of band secure boot key modification.\r
-\r
-  @return EFI_SUCCESS           Variable is updated successfully.\r
-  @return Others                Failed to update variable.\r
-\r
-**/\r
-EFI_STATUS\r
-VendorKeyIsModified (\r
-  VOID\r
-  )\r
-{\r
-  EFI_STATUS              Status;\r
-  VARIABLE_POINTER_TRACK  Variable;\r
-\r
-  if (mVendorKeyState == VENDOR_KEYS_MODIFIED) {\r
-    return EFI_SUCCESS;\r
-  }\r
-  mVendorKeyState = VENDOR_KEYS_MODIFIED;\r
-\r
-  FindVariable (EFI_VENDOR_KEYS_NV_VARIABLE_NAME, &gEfiVendorKeysNvGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  Status = UpdateVariable (\r
-             EFI_VENDOR_KEYS_NV_VARIABLE_NAME,\r
-             &gEfiVendorKeysNvGuid,\r
-             &mVendorKeyState,\r
-             sizeof (UINT8),\r
-             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS,\r
-             0,\r
-             0,\r
-             &Variable,\r
-             NULL\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  FindVariable (EFI_VENDOR_KEYS_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
-  return UpdateVariable (\r
-           EFI_VENDOR_KEYS_VARIABLE_NAME,\r
-           &gEfiGlobalVariableGuid,\r
-           &mVendorKeyState,\r
-           sizeof (UINT8),\r
-           EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
-           0,\r
-           0,\r
-           &Variable,\r
-           NULL\r
-           );\r
-}\r
-\r
-/**\r
-  Process variable with platform key for verification.\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-  This function will check attribute carefully to avoid authentication bypass.\r
-\r
-  @param[in]  VariableName                Name of Variable to be found.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-  @param[in]  Data                        Data pointer.\r
-  @param[in]  DataSize                    Size of Data found. If size is less than the\r
-                                          data, this value contains the required size.\r
-  @param[in]  Variable                    The variable information which is used to keep track of variable usage.\r
-  @param[in]  Attributes                  Attribute value of the variable\r
-  @param[in]  IsPk                        Indicate whether it is to process pk.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid parameter.\r
-  @return EFI_SECURITY_VIOLATION          The variable does NOT pass the validation.\r
-                                          check carried out by the firmware.\r
-  @return EFI_SUCCESS                     Variable passed validation successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-ProcessVarWithPk (\r
-  IN  CHAR16                    *VariableName,\r
-  IN  EFI_GUID                  *VendorGuid,\r
-  IN  VOID                      *Data,\r
-  IN  UINTN                     DataSize,\r
-  IN  VARIABLE_POINTER_TRACK    *Variable,\r
-  IN  UINT32                    Attributes OPTIONAL,\r
-  IN  BOOLEAN                   IsPk\r
-  )\r
-{\r
-  EFI_STATUS                  Status;\r
-  BOOLEAN                     Del;\r
-  UINT8                       *Payload;\r
-  UINTN                       PayloadSize;\r
-\r
-  if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0 ||\r
-      (Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
-    //\r
-    // PK, KEK and db/dbx/dbt should set EFI_VARIABLE_NON_VOLATILE attribute and should be a time-based\r
-    // authenticated variable.\r
-    //\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  Del = FALSE;\r
-  if ((InCustomMode() && UserPhysicalPresent()) || (mPlatformMode == SETUP_MODE && !IsPk)) {\r
-    Payload = (UINT8 *) Data + AUTHINFO2_SIZE (Data);\r
-    PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
-    if (PayloadSize == 0) {\r
-      Del = TRUE;\r
-    }\r
-\r
-    Status = CheckSignatureListFormat(VariableName, VendorGuid, Payload, PayloadSize);\r
-    if (EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-\r
-    Status = UpdateVariable (\r
-               VariableName,\r
-               VendorGuid,\r
-               Payload,\r
-               PayloadSize,\r
-               Attributes,\r
-               0,\r
-               0,\r
-               Variable,\r
-               &((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->TimeStamp\r
-               );\r
-    if (EFI_ERROR(Status)) {\r
-      return Status;\r
-    }\r
-\r
-    if ((mPlatformMode != SETUP_MODE) || IsPk) {\r
-      Status = VendorKeyIsModified ();\r
-    }\r
-  } else if (mPlatformMode == USER_MODE) {\r
-    //\r
-    // Verify against X509 Cert in PK database.\r
-    //\r
-    Status = VerifyTimeBasedPayload (\r
-               VariableName,\r
-               VendorGuid,\r
-               Data,\r
-               DataSize,\r
-               Variable,\r
-               Attributes,\r
-               AuthVarTypePk,\r
-               &Del\r
-               );\r
-  } else {\r
-    //\r
-    // Verify against the certificate in data payload.\r
-    //\r
-    Status = VerifyTimeBasedPayload (\r
-               VariableName,\r
-               VendorGuid,\r
-               Data,\r
-               DataSize,\r
-               Variable,\r
-               Attributes,\r
-               AuthVarTypePayload,\r
-               &Del\r
-               );\r
-  }\r
-\r
-  if (!EFI_ERROR(Status) && IsPk) {\r
-    if (mPlatformMode == SETUP_MODE && !Del) {\r
-      //\r
-      // If enroll PK in setup mode, need change to user mode.\r
-      //\r
-      Status = UpdatePlatformMode (USER_MODE);\r
-    } else if (mPlatformMode == USER_MODE && Del){\r
-      //\r
-      // If delete PK in user mode, need change to setup mode.\r
-      //\r
-      Status = UpdatePlatformMode (SETUP_MODE);\r
-    }\r
-  }\r
-\r
-  return Status;\r
-}\r
-\r
-/**\r
-  Process variable with key exchange key for verification.\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-  This function will check attribute carefully to avoid authentication bypass.\r
-\r
-  @param[in]  VariableName                Name of Variable to be found.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-  @param[in]  Data                        Data pointer.\r
-  @param[in]  DataSize                    Size of Data found. If size is less than the\r
-                                          data, this value contains the required size.\r
-  @param[in]  Variable                    The variable information which is used to keep track of variable usage.\r
-  @param[in]  Attributes                  Attribute value of the variable.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid parameter.\r
-  @return EFI_SECURITY_VIOLATION          The variable does NOT pass the validation\r
-                                          check carried out by the firmware.\r
-  @return EFI_SUCCESS                     Variable pass validation successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-ProcessVarWithKek (\r
-  IN  CHAR16                               *VariableName,\r
-  IN  EFI_GUID                             *VendorGuid,\r
-  IN  VOID                                 *Data,\r
-  IN  UINTN                                DataSize,\r
-  IN  VARIABLE_POINTER_TRACK               *Variable,\r
-  IN  UINT32                               Attributes OPTIONAL\r
-  )\r
-{\r
-  EFI_STATUS                      Status;\r
-  UINT8                           *Payload;\r
-  UINTN                           PayloadSize;\r
-\r
-  if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0 ||\r
-      (Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
-    //\r
-    // DB, DBX and DBT should set EFI_VARIABLE_NON_VOLATILE attribute and should be a time-based\r
-    // authenticated variable.\r
-    //\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  Status = EFI_SUCCESS;\r
-  if (mPlatformMode == USER_MODE && !(InCustomMode() && UserPhysicalPresent())) {\r
-    //\r
-    // Time-based, verify against X509 Cert KEK.\r
-    //\r
-    return VerifyTimeBasedPayload (\r
-             VariableName,\r
-             VendorGuid,\r
-             Data,\r
-             DataSize,\r
-             Variable,\r
-             Attributes,\r
-             AuthVarTypeKek,\r
-             NULL\r
-             );\r
-  } else {\r
-    //\r
-    // If in setup mode or custom secure boot mode, no authentication needed.\r
-    //\r
-    Payload = (UINT8 *) Data + AUTHINFO2_SIZE (Data);\r
-    PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
-\r
-    Status = CheckSignatureListFormat(VariableName, VendorGuid, Payload, PayloadSize);\r
-    if (EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-\r
-    Status = UpdateVariable (\r
-               VariableName,\r
-               VendorGuid,\r
-               Payload,\r
-               PayloadSize,\r
-               Attributes,\r
-               0,\r
-               0,\r
-               Variable,\r
-               &((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->TimeStamp\r
-               );\r
-    if (EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-\r
-    if (mPlatformMode != SETUP_MODE) {\r
-      Status = VendorKeyIsModified ();\r
-    }\r
-  }\r
-\r
-  return Status;\r
-}\r
-\r
-/**\r
-  Check if it is to delete auth variable.\r
-\r
-  @param[in] Data               Data pointer.\r
-  @param[in] DataSize           Size of Data.\r
-  @param[in] Variable           The variable information which is used to keep track of variable usage.\r
-  @param[in] Attributes         Attribute value of the variable.\r
-\r
-  @retval TRUE                  It is to delete auth variable.\r
-  @retval FALSE                 It is not to delete auth variable.\r
-\r
-**/\r
-BOOLEAN\r
-IsDeleteAuthVariable (\r
-  IN  VOID                      *Data,\r
-  IN  UINTN                     DataSize,\r
-  IN  VARIABLE_POINTER_TRACK    *Variable,\r
-  IN  UINT32                    Attributes\r
-  )\r
-{\r
-  BOOLEAN                       Del;\r
-  UINTN                         PayloadSize;\r
-\r
-  Del = FALSE;\r
-\r
-  //\r
-  // To delete a variable created with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS\r
-  // or the EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute,\r
-  // SetVariable must be used with attributes matching the existing variable\r
-  // and the DataSize set to the size of the AuthInfo descriptor.\r
-  //\r
-  if ((Variable->CurrPtr != NULL) &&\r
-      (Attributes == Variable->CurrPtr->Attributes) &&\r
-      ((Attributes & (EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)) != 0)) {\r
-    if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
-      PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
-      if (PayloadSize == 0) {\r
-        Del = TRUE;\r
-      }\r
-    } else {\r
-      PayloadSize = DataSize - AUTHINFO_SIZE;\r
-      if (PayloadSize == 0) {\r
-        Del = TRUE;\r
-      }\r
-    }\r
-  }\r
-\r
-  return Del;\r
-}\r
-\r
-/**\r
-  Process variable with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS/EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-  This function will check attribute carefully to avoid authentication bypass.\r
-\r
-  @param[in]  VariableName                Name of Variable to be found.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-\r
-  @param[in]  Data                        Data pointer.\r
-  @param[in]  DataSize                    Size of Data.\r
-  @param[in]  Variable                    The variable information which is used to keep track of variable usage.\r
-  @param[in]  Attributes                  Attribute value of the variable.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid parameter.\r
-  @return EFI_WRITE_PROTECTED             Variable is write-protected and needs authentication with\r
-                                          EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS set.\r
-  @return EFI_OUT_OF_RESOURCES            The Database to save the public key is full.\r
-  @return EFI_SECURITY_VIOLATION          The variable is with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS\r
-                                          set, but the AuthInfo does NOT pass the validation\r
-                                          check carried out by the firmware.\r
-  @return EFI_SUCCESS                     Variable is not write-protected or pass validation successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-ProcessVariable (\r
-  IN     CHAR16                             *VariableName,\r
-  IN     EFI_GUID                           *VendorGuid,\r
-  IN     VOID                               *Data,\r
-  IN     UINTN                              DataSize,\r
-  IN     VARIABLE_POINTER_TRACK             *Variable,\r
-  IN     UINT32                             Attributes\r
-  )\r
-{\r
-  EFI_STATUS                      Status;\r
-  BOOLEAN                         IsDeletion;\r
-  BOOLEAN                         IsFirstTime;\r
-  UINT8                           *PubKey;\r
-  EFI_VARIABLE_AUTHENTICATION     *CertData;\r
-  EFI_CERT_BLOCK_RSA_2048_SHA256  *CertBlock;\r
-  UINT32                          KeyIndex;\r
-  UINT64                          MonotonicCount;\r
-  VARIABLE_ENTRY_CONSISTENCY      VariableDataEntry;\r
-\r
-  KeyIndex    = 0;\r
-  CertData    = NULL;\r
-  CertBlock   = NULL;\r
-  PubKey      = NULL;\r
-  IsDeletion  = FALSE;\r
-  Status      = EFI_SUCCESS;\r
-\r
-  if (IsDeleteAuthVariable (Data, DataSize, Variable, Attributes) && UserPhysicalPresent()) {\r
-    //\r
-    // Allow the delete operation of common authenticated variable at user physical presence.\r
-    //\r
-    if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
-      Status = DeleteCertsFromDb (VariableName, VendorGuid);\r
-    }\r
-    if (!EFI_ERROR (Status)) {\r
-      Status = UpdateVariable (\r
-                 VariableName,\r
-                 VendorGuid,\r
-                 NULL,\r
-                 0,\r
-                 0,\r
-                 0,\r
-                 0,\r
-                 Variable,\r
-                 NULL\r
-                 );\r
-    }\r
-    return Status;\r
-  }\r
-\r
-  if (NeedPhysicallyPresent (VariableName, VendorGuid) && !UserPhysicalPresent()) {\r
-    //\r
-    // This variable is protected, only physical present user could modify its value.\r
-    //\r
-    return EFI_SECURITY_VIOLATION;\r
-  }\r
-\r
-  //\r
-  // A time-based authenticated variable and a count-based authenticated variable\r
-  // can't be updated by each other.\r
-  //\r
-  if (Variable->CurrPtr != NULL) {\r
-    if (((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) &&\r
-        ((Variable->CurrPtr->Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0)) {\r
-      return EFI_SECURITY_VIOLATION;\r
-    }\r
-\r
-    if (((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) &&\r
-        ((Variable->CurrPtr->Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0)) {\r
-      return EFI_SECURITY_VIOLATION;\r
-    }\r
-  }\r
-\r
-  //\r
-  // Process Time-based Authenticated variable.\r
-  //\r
-  if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
-    return VerifyTimeBasedPayload (\r
-             VariableName,\r
-             VendorGuid,\r
-             Data,\r
-             DataSize,\r
-             Variable,\r
-             Attributes,\r
-             AuthVarTypePriv,\r
-             NULL\r
-             );\r
-  }\r
-\r
-  //\r
-  // Determine if first time SetVariable with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS.\r
-  //\r
-  if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
-    //\r
-    // Determine current operation type.\r
-    //\r
-    if (DataSize == AUTHINFO_SIZE) {\r
-      IsDeletion = TRUE;\r
-    }\r
-    //\r
-    // Determine whether this is the first time with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS set.\r
-    //\r
-    if (Variable->CurrPtr == NULL) {\r
-      IsFirstTime = TRUE;\r
-    } else if ((Variable->CurrPtr->Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
-      IsFirstTime = TRUE;\r
-    } else {\r
-      KeyIndex   = Variable->CurrPtr->PubKeyIndex;\r
-      IsFirstTime = FALSE;\r
-    }\r
-  } else if ((Variable->CurrPtr != NULL) &&\r
-             ((Variable->CurrPtr->Attributes & (EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)) != 0)\r
-            ) {\r
-    //\r
-    // If the variable is already write-protected, it always needs authentication before update.\r
-    //\r
-    return EFI_WRITE_PROTECTED;\r
-  } else {\r
-    //\r
-    // If without EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, set and attributes collision.\r
-    // That means it is not authenticated variable, just update variable as usual.\r
-    //\r
-    Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, 0, 0, Variable, NULL);\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // Get PubKey and check Monotonic Count value corresponding to the variable.\r
-  //\r
-  CertData  = (EFI_VARIABLE_AUTHENTICATION *) Data;\r
-  CertBlock = (EFI_CERT_BLOCK_RSA_2048_SHA256 *) (CertData->AuthInfo.CertData);\r
-  PubKey    = CertBlock->PublicKey;\r
-\r
-  //\r
-  // Update Monotonic Count value.\r
-  //\r
-  MonotonicCount = CertData->MonotonicCount;\r
-\r
-  if (!IsFirstTime) {\r
-    //\r
-    // 2 cases need to check here\r
-    //   1. Internal PubKey variable. PubKeyIndex is always 0\r
-    //   2. Other counter-based AuthVariable. Check input PubKey.\r
-    //\r
-    if (KeyIndex == 0 || CompareMem (PubKey, mPubKeyStore + (KeyIndex - 1) * EFI_CERT_TYPE_RSA2048_SIZE, EFI_CERT_TYPE_RSA2048_SIZE) != 0) {\r
-      return EFI_SECURITY_VIOLATION;\r
-    }\r
-    //\r
-    // Compare the current monotonic count and ensure that it is greater than the last SetVariable\r
-    // operation with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS attribute set.\r
-    //\r
-    if (CertData->MonotonicCount <= Variable->CurrPtr->MonotonicCount) {\r
-      //\r
-      // Monotonic count check fail, suspicious replay attack, return EFI_SECURITY_VIOLATION.\r
-      //\r
-      return EFI_SECURITY_VIOLATION;\r
-    }\r
-  }\r
-  //\r
-  // Verify the certificate in Data payload.\r
-  //\r
-  Status = VerifyCounterBasedPayload (Data, DataSize, PubKey);\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // Now, the signature has been verified!\r
-  //\r
-  if (IsFirstTime && !IsDeletion) {\r
-    VariableDataEntry.VariableSize = DataSize - AUTHINFO_SIZE;\r
-    VariableDataEntry.Guid         = VendorGuid;\r
-    VariableDataEntry.Name         = VariableName;\r
-\r
-    //\r
-    // Update public key database variable if need.\r
-    //\r
-    KeyIndex = AddPubKeyInStore (PubKey, &VariableDataEntry);\r
-    if (KeyIndex == 0) {\r
-      return EFI_OUT_OF_RESOURCES;\r
-    }\r
-  }\r
-\r
-  //\r
-  // Verification pass.\r
-  //\r
-  return UpdateVariable (VariableName, VendorGuid, (UINT8*)Data + AUTHINFO_SIZE, DataSize - AUTHINFO_SIZE, Attributes, KeyIndex, MonotonicCount, Variable, NULL);\r
-}\r
-\r
-/**\r
-  Merge two buffers which formatted as EFI_SIGNATURE_LIST. Only the new EFI_SIGNATURE_DATA\r
-  will be appended to the original EFI_SIGNATURE_LIST, duplicate EFI_SIGNATURE_DATA\r
-  will be ignored.\r
-\r
-  @param[in, out]  Data              Pointer to original EFI_SIGNATURE_LIST.\r
-  @param[in]       DataSize          Size of Data buffer.\r
-  @param[in]       FreeBufSize       Size of free data buffer\r
-  @param[in]       NewData           Pointer to new EFI_SIGNATURE_LIST to be appended.\r
-  @param[in]       NewDataSize       Size of NewData buffer.\r
-  @param[out]      MergedBufSize     Size of the merged buffer\r
-\r
-  @return EFI_BUFFER_TOO_SMALL if input Data buffer overflowed\r
-\r
-**/\r
-EFI_STATUS\r
-AppendSignatureList (\r
-  IN  OUT VOID            *Data,\r
-  IN  UINTN               DataSize,\r
-  IN  UINTN               FreeBufSize,\r
-  IN  VOID                *NewData,\r
-  IN  UINTN               NewDataSize,\r
-  OUT UINTN               *MergedBufSize\r
-  )\r
-{\r
-  EFI_SIGNATURE_LIST  *CertList;\r
-  EFI_SIGNATURE_DATA  *Cert;\r
-  UINTN               CertCount;\r
-  EFI_SIGNATURE_LIST  *NewCertList;\r
-  EFI_SIGNATURE_DATA  *NewCert;\r
-  UINTN               NewCertCount;\r
-  UINTN               Index;\r
-  UINTN               Index2;\r
-  UINTN               Size;\r
-  UINT8               *Tail;\r
-  UINTN               CopiedCount;\r
-  UINTN               SignatureListSize;\r
-  BOOLEAN             IsNewCert;\r
-\r
-  Tail = (UINT8 *) Data + DataSize;\r
-\r
-  NewCertList = (EFI_SIGNATURE_LIST *) NewData;\r
-  while ((NewDataSize > 0) && (NewDataSize >= NewCertList->SignatureListSize)) {\r
-    NewCert      = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCertList + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
-    NewCertCount = (NewCertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - NewCertList->SignatureHeaderSize) / NewCertList->SignatureSize;\r
-\r
-    CopiedCount = 0;\r
-    for (Index = 0; Index < NewCertCount; Index++) {\r
-      IsNewCert = TRUE;\r
-\r
-      Size = DataSize;\r
-      CertList = (EFI_SIGNATURE_LIST *) Data;\r
-      while ((Size > 0) && (Size >= CertList->SignatureListSize)) {\r
-        if (CompareGuid (&CertList->SignatureType, &NewCertList->SignatureType) &&\r
-           (CertList->SignatureSize == NewCertList->SignatureSize)) {\r
-          Cert      = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
-          CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
-          for (Index2 = 0; Index2 < CertCount; Index2++) {\r
-            //\r
-            // Iterate each Signature Data in this Signature List.\r
-            //\r
-            if (CompareMem (NewCert, Cert, CertList->SignatureSize) == 0) {\r
-              IsNewCert = FALSE;\r
-              break;\r
-            }\r
-            Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
-          }\r
-        }\r
-\r
-        if (!IsNewCert) {\r
-          break;\r
-        }\r
-        Size -= CertList->SignatureListSize;\r
-        CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
-      }\r
-\r
-      if (IsNewCert) {\r
-        //\r
-        // New EFI_SIGNATURE_DATA, append it.\r
-        //\r
-        if (CopiedCount == 0) {\r
-          if (FreeBufSize < sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize) {\r
-            return EFI_BUFFER_TOO_SMALL;\r
-          }\r
-\r
-          //\r
-          // Copy EFI_SIGNATURE_LIST header for only once.\r
-          //\r
-\r
-          CopyMem (Tail, NewCertList, sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
-          Tail = Tail + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize;\r
-          FreeBufSize -= sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize;\r
-        }\r
-\r
-        if (FreeBufSize < NewCertList->SignatureSize) {\r
-          return EFI_BUFFER_TOO_SMALL;\r
-        }\r
-        CopyMem (Tail, NewCert, NewCertList->SignatureSize);\r
-        Tail += NewCertList->SignatureSize;\r
-        FreeBufSize -= NewCertList->SignatureSize;\r
-        CopiedCount++;\r
-      }\r
-\r
-      NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCert + NewCertList->SignatureSize);\r
-    }\r
-\r
-    //\r
-    // Update SignatureListSize in newly appended EFI_SIGNATURE_LIST.\r
-    //\r
-    if (CopiedCount != 0) {\r
-      SignatureListSize = sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize + (CopiedCount * NewCertList->SignatureSize);\r
-      CertList = (EFI_SIGNATURE_LIST *) (Tail - SignatureListSize);\r
-      CertList->SignatureListSize = (UINT32) SignatureListSize;\r
-    }\r
-\r
-    NewDataSize -= NewCertList->SignatureListSize;\r
-    NewCertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) NewCertList + NewCertList->SignatureListSize);\r
-  }\r
-\r
-  *MergedBufSize = (Tail - (UINT8 *) Data);\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Compare two EFI_TIME data.\r
-\r
-\r
-  @param FirstTime           A pointer to the first EFI_TIME data.\r
-  @param SecondTime          A pointer to the second EFI_TIME data.\r
-\r
-  @retval  TRUE              The FirstTime is not later than the SecondTime.\r
-  @retval  FALSE             The FirstTime is later than the SecondTime.\r
-\r
-**/\r
-BOOLEAN\r
-CompareTimeStamp (\r
-  IN EFI_TIME               *FirstTime,\r
-  IN EFI_TIME               *SecondTime\r
-  )\r
-{\r
-  if (FirstTime->Year != SecondTime->Year) {\r
-    return (BOOLEAN) (FirstTime->Year < SecondTime->Year);\r
-  } else if (FirstTime->Month != SecondTime->Month) {\r
-    return (BOOLEAN) (FirstTime->Month < SecondTime->Month);\r
-  } else if (FirstTime->Day != SecondTime->Day) {\r
-    return (BOOLEAN) (FirstTime->Day < SecondTime->Day);\r
-  } else if (FirstTime->Hour != SecondTime->Hour) {\r
-    return (BOOLEAN) (FirstTime->Hour < SecondTime->Hour);\r
-  } else if (FirstTime->Minute != SecondTime->Minute) {\r
-    return (BOOLEAN) (FirstTime->Minute < SecondTime->Minute);\r
-  }\r
-\r
-  return (BOOLEAN) (FirstTime->Second <= SecondTime->Second);\r
-}\r
-\r
-/**\r
-  Find matching signer's certificates for common authenticated variable\r
-  by corresponding VariableName and VendorGuid from "certdb".\r
-\r
-  The data format of "certdb":\r
-  //\r
-  //     UINT32 CertDbListSize;\r
-  // /// AUTH_CERT_DB_DATA Certs1[];\r
-  // /// AUTH_CERT_DB_DATA Certs2[];\r
-  // /// ...\r
-  // /// AUTH_CERT_DB_DATA Certsn[];\r
-  //\r
-\r
-  @param[in]  VariableName   Name of authenticated Variable.\r
-  @param[in]  VendorGuid     Vendor GUID of authenticated Variable.\r
-  @param[in]  Data           Pointer to variable "certdb".\r
-  @param[in]  DataSize       Size of variable "certdb".\r
-  @param[out] CertOffset     Offset of matching CertData, from starting of Data.\r
-  @param[out] CertDataSize   Length of CertData in bytes.\r
-  @param[out] CertNodeOffset Offset of matching AUTH_CERT_DB_DATA , from\r
-                             starting of Data.\r
-  @param[out] CertNodeSize   Length of AUTH_CERT_DB_DATA in bytes.\r
-\r
-  @retval  EFI_INVALID_PARAMETER Any input parameter is invalid.\r
-  @retval  EFI_NOT_FOUND         Fail to find matching certs.\r
-  @retval  EFI_SUCCESS           Find matching certs and output parameters.\r
-\r
-**/\r
-EFI_STATUS\r
-FindCertsFromDb (\r
-  IN     CHAR16           *VariableName,\r
-  IN     EFI_GUID         *VendorGuid,\r
-  IN     UINT8            *Data,\r
-  IN     UINTN            DataSize,\r
-  OUT    UINT32           *CertOffset,    OPTIONAL\r
-  OUT    UINT32           *CertDataSize,  OPTIONAL\r
-  OUT    UINT32           *CertNodeOffset,OPTIONAL\r
-  OUT    UINT32           *CertNodeSize   OPTIONAL\r
-  )\r
-{\r
-  UINT32                  Offset;\r
-  AUTH_CERT_DB_DATA       *Ptr;\r
-  UINT32                  CertSize;\r
-  UINT32                  NameSize;\r
-  UINT32                  NodeSize;\r
-  UINT32                  CertDbListSize;\r
-\r
-  if ((VariableName == NULL) || (VendorGuid == NULL) || (Data == NULL)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  //\r
-  // Check whether DataSize matches recorded CertDbListSize.\r
-  //\r
-  if (DataSize < sizeof (UINT32)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  CertDbListSize = ReadUnaligned32 ((UINT32 *) Data);\r
-\r
-  if (CertDbListSize != (UINT32) DataSize) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  Offset = sizeof (UINT32);\r
-\r
-  //\r
-  // Get corresponding certificates by VendorGuid and VariableName.\r
-  //\r
-  while (Offset < (UINT32) DataSize) {\r
-    Ptr = (AUTH_CERT_DB_DATA *) (Data + Offset);\r
-    //\r
-    // Check whether VendorGuid matches.\r
-    //\r
-    if (CompareGuid (&Ptr->VendorGuid, VendorGuid)) {\r
-      NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
-      NameSize = ReadUnaligned32 (&Ptr->NameSize);\r
-      CertSize = ReadUnaligned32 (&Ptr->CertDataSize);\r
-\r
-      if (NodeSize != sizeof (EFI_GUID) + sizeof (UINT32) * 3 + CertSize +\r
-          sizeof (CHAR16) * NameSize) {\r
-        return EFI_INVALID_PARAMETER;\r
-      }\r
-\r
-      Offset = Offset + sizeof (EFI_GUID) + sizeof (UINT32) * 3;\r
-      //\r
-      // Check whether VariableName matches.\r
-      //\r
-      if ((NameSize == StrLen (VariableName)) &&\r
-          (CompareMem (Data + Offset, VariableName, NameSize * sizeof (CHAR16)) == 0)) {\r
-        Offset = Offset + NameSize * sizeof (CHAR16);\r
-\r
-        if (CertOffset != NULL) {\r
-          *CertOffset = Offset;\r
-        }\r
-\r
-        if (CertDataSize != NULL) {\r
-          *CertDataSize = CertSize;\r
-        }\r
-\r
-        if (CertNodeOffset != NULL) {\r
-          *CertNodeOffset = (UINT32) ((UINT8 *) Ptr - Data);\r
-        }\r
-\r
-        if (CertNodeSize != NULL) {\r
-          *CertNodeSize = NodeSize;\r
-        }\r
-\r
-        return EFI_SUCCESS;\r
-      } else {\r
-        Offset = Offset + NameSize * sizeof (CHAR16) + CertSize;\r
-      }\r
-    } else {\r
-      NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
-      Offset   = Offset + NodeSize;\r
-    }\r
-  }\r
-\r
-  return EFI_NOT_FOUND;\r
-}\r
-\r
-/**\r
-  Retrieve signer's certificates for common authenticated variable\r
-  by corresponding VariableName and VendorGuid from "certdb".\r
-\r
-  @param[in]  VariableName   Name of authenticated Variable.\r
-  @param[in]  VendorGuid     Vendor GUID of authenticated Variable.\r
-  @param[out] CertData       Pointer to signer's certificates.\r
-  @param[out] CertDataSize   Length of CertData in bytes.\r
-\r
-  @retval  EFI_INVALID_PARAMETER Any input parameter is invalid.\r
-  @retval  EFI_NOT_FOUND         Fail to find "certdb" or matching certs.\r
-  @retval  EFI_SUCCESS           Get signer's certificates successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-GetCertsFromDb (\r
-  IN     CHAR16           *VariableName,\r
-  IN     EFI_GUID         *VendorGuid,\r
-  OUT    UINT8            **CertData,\r
-  OUT    UINT32           *CertDataSize\r
-  )\r
-{\r
-  VARIABLE_POINTER_TRACK  CertDbVariable;\r
-  EFI_STATUS              Status;\r
-  UINT8                   *Data;\r
-  UINTN                   DataSize;\r
-  UINT32                  CertOffset;\r
-\r
-  if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL) || (CertDataSize == NULL)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  //\r
-  // Get variable "certdb".\r
-  //\r
-  Status = FindVariable (\r
-             EFI_CERT_DB_NAME,\r
-             &gEfiCertDbGuid,\r
-             &CertDbVariable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  DataSize  = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
-  Data      = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
-  if ((DataSize == 0) || (Data == NULL)) {\r
-    ASSERT (FALSE);\r
-    return EFI_NOT_FOUND;\r
-  }\r
-\r
-  Status = FindCertsFromDb (\r
-             VariableName,\r
-             VendorGuid,\r
-             Data,\r
-             DataSize,\r
-             &CertOffset,\r
-             CertDataSize,\r
-             NULL,\r
-             NULL\r
-             );\r
-\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  *CertData = Data + CertOffset;\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Delete matching signer's certificates when deleting common authenticated\r
-  variable by corresponding VariableName and VendorGuid from "certdb".\r
-\r
-  @param[in]  VariableName   Name of authenticated Variable.\r
-  @param[in]  VendorGuid     Vendor GUID of authenticated Variable.\r
-\r
-  @retval  EFI_INVALID_PARAMETER Any input parameter is invalid.\r
-  @retval  EFI_NOT_FOUND         Fail to find "certdb" or matching certs.\r
-  @retval  EFI_OUT_OF_RESOURCES  The operation is failed due to lack of resources.\r
-  @retval  EFI_SUCCESS           The operation is completed successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-DeleteCertsFromDb (\r
-  IN     CHAR16           *VariableName,\r
-  IN     EFI_GUID         *VendorGuid\r
-  )\r
-{\r
-  VARIABLE_POINTER_TRACK  CertDbVariable;\r
-  EFI_STATUS              Status;\r
-  UINT8                   *Data;\r
-  UINTN                   DataSize;\r
-  UINT32                  VarAttr;\r
-  UINT32                  CertNodeOffset;\r
-  UINT32                  CertNodeSize;\r
-  UINT8                   *NewCertDb;\r
-  UINT32                  NewCertDbSize;\r
-\r
-  if ((VariableName == NULL) || (VendorGuid == NULL)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  //\r
-  // Get variable "certdb".\r
-  //\r
-  Status = FindVariable (\r
-             EFI_CERT_DB_NAME,\r
-             &gEfiCertDbGuid,\r
-             &CertDbVariable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  DataSize  = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
-  Data      = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
-  if ((DataSize == 0) || (Data == NULL)) {\r
-    ASSERT (FALSE);\r
-    return EFI_NOT_FOUND;\r
-  }\r
-\r
-  if (DataSize == sizeof (UINT32)) {\r
-    //\r
-    // There is no certs in certdb.\r
-    //\r
-    return EFI_SUCCESS;\r
-  }\r
-\r
-  //\r
-  // Get corresponding cert node from certdb.\r
-  //\r
-  Status = FindCertsFromDb (\r
-             VariableName,\r
-             VendorGuid,\r
-             Data,\r
-             DataSize,\r
-             NULL,\r
-             NULL,\r
-             &CertNodeOffset,\r
-             &CertNodeSize\r
-             );\r
-\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  if (DataSize < (CertNodeOffset + CertNodeSize)) {\r
-    return EFI_NOT_FOUND;\r
-  }\r
-\r
-  //\r
-  // Construct new data content of variable "certdb".\r
-  //\r
-  NewCertDbSize = (UINT32) DataSize - CertNodeSize;\r
-  NewCertDb     = (UINT8*) mCertDbStore;\r
-\r
-  //\r
-  // Copy the DB entries before deleting node.\r
-  //\r
-  CopyMem (NewCertDb, Data, CertNodeOffset);\r
-  //\r
-  // Update CertDbListSize.\r
-  //\r
-  CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
-  //\r
-  // Copy the DB entries after deleting node.\r
-  //\r
-  if (DataSize > (CertNodeOffset + CertNodeSize)) {\r
-    CopyMem (\r
-      NewCertDb + CertNodeOffset,\r
-      Data + CertNodeOffset + CertNodeSize,\r
-      DataSize - CertNodeOffset - CertNodeSize\r
-      );\r
-  }\r
-\r
-  //\r
-  // Set "certdb".\r
-  //\r
-  VarAttr  = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
-  Status   = UpdateVariable (\r
-               EFI_CERT_DB_NAME,\r
-               &gEfiCertDbGuid,\r
-               NewCertDb,\r
-               NewCertDbSize,\r
-               VarAttr,\r
-               0,\r
-               0,\r
-               &CertDbVariable,\r
-               NULL\r
-               );\r
-\r
-  return Status;\r
-}\r
-\r
-/**\r
-  Insert signer's certificates for common authenticated variable with VariableName\r
-  and VendorGuid in AUTH_CERT_DB_DATA to "certdb".\r
-\r
-  @param[in]  VariableName   Name of authenticated Variable.\r
-  @param[in]  VendorGuid     Vendor GUID of authenticated Variable.\r
-  @param[in]  CertData       Pointer to signer's certificates.\r
-  @param[in]  CertDataSize   Length of CertData in bytes.\r
-\r
-  @retval  EFI_INVALID_PARAMETER Any input parameter is invalid.\r
-  @retval  EFI_ACCESS_DENIED     An AUTH_CERT_DB_DATA entry with same VariableName\r
-                                 and VendorGuid already exists.\r
-  @retval  EFI_OUT_OF_RESOURCES  The operation is failed due to lack of resources.\r
-  @retval  EFI_SUCCESS           Insert an AUTH_CERT_DB_DATA entry to "certdb"\r
-\r
-**/\r
-EFI_STATUS\r
-InsertCertsToDb (\r
-  IN     CHAR16           *VariableName,\r
-  IN     EFI_GUID         *VendorGuid,\r
-  IN     UINT8            *CertData,\r
-  IN     UINTN            CertDataSize\r
-  )\r
-{\r
-  VARIABLE_POINTER_TRACK  CertDbVariable;\r
-  EFI_STATUS              Status;\r
-  UINT8                   *Data;\r
-  UINTN                   DataSize;\r
-  UINT32                  VarAttr;\r
-  UINT8                   *NewCertDb;\r
-  UINT32                  NewCertDbSize;\r
-  UINT32                  CertNodeSize;\r
-  UINT32                  NameSize;\r
-  AUTH_CERT_DB_DATA       *Ptr;\r
-\r
-  if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  //\r
-  // Get variable "certdb".\r
-  //\r
-  Status = FindVariable (\r
-             EFI_CERT_DB_NAME,\r
-             &gEfiCertDbGuid,\r
-             &CertDbVariable,\r
-             &mVariableModuleGlobal->VariableGlobal,\r
-             FALSE\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  DataSize  = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
-  Data      = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
-  if ((DataSize == 0) || (Data == NULL)) {\r
-    ASSERT (FALSE);\r
-    return EFI_NOT_FOUND;\r
-  }\r
-\r
-  //\r
-  // Find whether matching cert node already exists in "certdb".\r
-  // If yes return error.\r
-  //\r
-  Status = FindCertsFromDb (\r
-             VariableName,\r
-             VendorGuid,\r
-             Data,\r
-             DataSize,\r
-             NULL,\r
-             NULL,\r
-             NULL,\r
-             NULL\r
-             );\r
-\r
-  if (!EFI_ERROR (Status)) {\r
-    ASSERT (FALSE);\r
-    return EFI_ACCESS_DENIED;\r
-  }\r
-\r
-  //\r
-  // Construct new data content of variable "certdb".\r
-  //\r
-  NameSize      = (UINT32) StrLen (VariableName);\r
-  CertNodeSize  = sizeof (AUTH_CERT_DB_DATA) + (UINT32) CertDataSize + NameSize * sizeof (CHAR16);\r
-  NewCertDbSize = (UINT32) DataSize + CertNodeSize;\r
-  if (NewCertDbSize > mMaxCertDbSize) {\r
-    return EFI_OUT_OF_RESOURCES;\r
-  }\r
-  NewCertDb     = (UINT8*) mCertDbStore;\r
-\r
-  //\r
-  // Copy the DB entries before deleting node.\r
-  //\r
-  CopyMem (NewCertDb, Data, DataSize);\r
-  //\r
-  // Update CertDbListSize.\r
-  //\r
-  CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
-  //\r
-  // Construct new cert node.\r
-  //\r
-  Ptr = (AUTH_CERT_DB_DATA *) (NewCertDb + DataSize);\r
-  CopyGuid (&Ptr->VendorGuid, VendorGuid);\r
-  CopyMem (&Ptr->CertNodeSize, &CertNodeSize, sizeof (UINT32));\r
-  CopyMem (&Ptr->NameSize, &NameSize, sizeof (UINT32));\r
-  CopyMem (&Ptr->CertDataSize, &CertDataSize, sizeof (UINT32));\r
-\r
-  CopyMem (\r
-    (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA),\r
-    VariableName,\r
-    NameSize * sizeof (CHAR16)\r
-    );\r
-\r
-  CopyMem (\r
-    (UINT8 *) Ptr +  sizeof (AUTH_CERT_DB_DATA) + NameSize * sizeof (CHAR16),\r
-    CertData,\r
-    CertDataSize\r
-    );\r
-\r
-  //\r
-  // Set "certdb".\r
-  //\r
-  VarAttr  = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
-  Status   = UpdateVariable (\r
-               EFI_CERT_DB_NAME,\r
-               &gEfiCertDbGuid,\r
-               NewCertDb,\r
-               NewCertDbSize,\r
-               VarAttr,\r
-               0,\r
-               0,\r
-               &CertDbVariable,\r
-               NULL\r
-               );\r
-\r
-  return Status;\r
-}\r
-\r
-/**\r
-  Process variable with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-\r
-  @param[in]  VariableName                Name of Variable to be found.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-  @param[in]  Data                        Data pointer.\r
-  @param[in]  DataSize                    Size of Data found. If size is less than the\r
-                                          data, this value contains the required size.\r
-  @param[in]  Variable                    The variable information which is used to keep track of variable usage.\r
-  @param[in]  Attributes                  Attribute value of the variable.\r
-  @param[in]  AuthVarType                 Verify against PK, KEK database, private database or certificate in data payload.\r
-  @param[out] VarDel                      Delete the variable or not.\r
-\r
-  @retval EFI_INVALID_PARAMETER           Invalid parameter.\r
-  @retval EFI_SECURITY_VIOLATION          The variable does NOT pass the validation\r
-                                          check carried out by the firmware.\r
-  @retval EFI_OUT_OF_RESOURCES            Failed to process variable due to lack\r
-                                          of resources.\r
-  @retval EFI_SUCCESS                     Variable pass validation successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-VerifyTimeBasedPayload (\r
-  IN     CHAR16                             *VariableName,\r
-  IN     EFI_GUID                           *VendorGuid,\r
-  IN     VOID                               *Data,\r
-  IN     UINTN                              DataSize,\r
-  IN     VARIABLE_POINTER_TRACK             *Variable,\r
-  IN     UINT32                             Attributes,\r
-  IN     AUTHVAR_TYPE                       AuthVarType,\r
-  OUT    BOOLEAN                            *VarDel\r
-  )\r
-{\r
-  UINT8                            *RootCert;\r
-  UINT8                            *SigData;\r
-  UINT8                            *PayloadPtr;\r
-  UINTN                            RootCertSize;\r
-  UINTN                            Index;\r
-  UINTN                            CertCount;\r
-  UINTN                            PayloadSize;\r
-  UINT32                           Attr;\r
-  UINT32                           SigDataSize;\r
-  UINT32                           KekDataSize;\r
-  BOOLEAN                          VerifyStatus;\r
-  EFI_STATUS                       Status;\r
-  EFI_SIGNATURE_LIST               *CertList;\r
-  EFI_SIGNATURE_DATA               *Cert;\r
-  VARIABLE_POINTER_TRACK           KekVariable;\r
-  EFI_VARIABLE_AUTHENTICATION_2    *CertData;\r
-  UINT8                            *NewData;\r
-  UINTN                            NewDataSize;\r
-  VARIABLE_POINTER_TRACK           PkVariable;\r
-  UINT8                            *Buffer;\r
-  UINTN                            Length;\r
-  UINT8                            *SignerCerts;\r
-  UINTN                            CertStackSize;\r
-  UINT8                            *CertsInCertDb;\r
-  UINT32                           CertsSizeinDb;\r
-\r
-  VerifyStatus           = FALSE;\r
-  CertData               = NULL;\r
-  NewData                = NULL;\r
-  Attr                   = Attributes;\r
-  SignerCerts            = NULL;\r
-  RootCert               = NULL;\r
-  CertsInCertDb          = NULL;\r
-\r
-  //\r
-  // When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is\r
-  // set, then the Data buffer shall begin with an instance of a complete (and serialized)\r
-  // EFI_VARIABLE_AUTHENTICATION_2 descriptor. The descriptor shall be followed by the new\r
-  // variable value and DataSize shall reflect the combined size of the descriptor and the new\r
-  // variable value. The authentication descriptor is not part of the variable data and is not\r
-  // returned by subsequent calls to GetVariable().\r
-  //\r
-  CertData = (EFI_VARIABLE_AUTHENTICATION_2 *) Data;\r
-\r
-  //\r
-  // Verify that Pad1, Nanosecond, TimeZone, Daylight and Pad2 components of the\r
-  // TimeStamp value are set to zero.\r
-  //\r
-  if ((CertData->TimeStamp.Pad1 != 0) ||\r
-      (CertData->TimeStamp.Nanosecond != 0) ||\r
-      (CertData->TimeStamp.TimeZone != 0) ||\r
-      (CertData->TimeStamp.Daylight != 0) ||\r
-      (CertData->TimeStamp.Pad2 != 0)) {\r
-    return EFI_SECURITY_VIOLATION;\r
-  }\r
-\r
-  if ((Variable->CurrPtr != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
-    if (CompareTimeStamp (&CertData->TimeStamp, &Variable->CurrPtr->TimeStamp)) {\r
-      //\r
-      // TimeStamp check fail, suspicious replay attack, return EFI_SECURITY_VIOLATION.\r
-      //\r
-      return EFI_SECURITY_VIOLATION;\r
-    }\r
-  }\r
-\r
-  //\r
-  // wCertificateType should be WIN_CERT_TYPE_EFI_GUID.\r
-  // Cert type should be EFI_CERT_TYPE_PKCS7_GUID.\r
-  //\r
-  if ((CertData->AuthInfo.Hdr.wCertificateType != WIN_CERT_TYPE_EFI_GUID) ||\r
-      !CompareGuid (&CertData->AuthInfo.CertType, &gEfiCertPkcs7Guid)) {\r
-    //\r
-    // Invalid AuthInfo type, return EFI_SECURITY_VIOLATION.\r
-    //\r
-    return EFI_SECURITY_VIOLATION;\r
-  }\r
-\r
-  //\r
-  // Find out Pkcs7 SignedData which follows the EFI_VARIABLE_AUTHENTICATION_2 descriptor.\r
-  // AuthInfo.Hdr.dwLength is the length of the entire certificate, including the length of the header.\r
-  //\r
-  SigData = CertData->AuthInfo.CertData;\r
-  SigDataSize = CertData->AuthInfo.Hdr.dwLength - (UINT32) (OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData));\r
-\r
-  //\r
-  // Find out the new data payload which follows Pkcs7 SignedData directly.\r
-  //\r
-  PayloadPtr = SigData + SigDataSize;\r
-  PayloadSize = DataSize - OFFSET_OF_AUTHINFO2_CERT_DATA - (UINTN) SigDataSize;\r
-\r
-  //\r
-  // Construct a serialization buffer of the values of the VariableName, VendorGuid and Attributes\r
-  // parameters of the SetVariable() call and the TimeStamp component of the\r
-  // EFI_VARIABLE_AUTHENTICATION_2 descriptor followed by the variable's new value\r
-  // i.e. (VariableName, VendorGuid, Attributes, TimeStamp, Data)\r
-  //\r
-  NewDataSize = PayloadSize + sizeof (EFI_TIME) + sizeof (UINT32) +\r
-                sizeof (EFI_GUID) + StrSize (VariableName) - sizeof (CHAR16);\r
-  //\r
-  // Here is to reuse scratch data area(at the end of volatile variable store)\r
-  // to reduce SMRAM consumption for SMM variable driver.\r
-  // The scratch buffer is enough to hold the serialized data and safe to use,\r
-  // because it will be used at here to do verification only first\r
-  // and then used in UpdateVariable() for a time based auth variable set.\r
-  //\r
-  NewData = (UINT8 *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));\r
-\r
-  Buffer = NewData;\r
-  Length = StrLen (VariableName) * sizeof (CHAR16);\r
-  CopyMem (Buffer, VariableName, Length);\r
-  Buffer += Length;\r
-\r
-  Length = sizeof (EFI_GUID);\r
-  CopyMem (Buffer, VendorGuid, Length);\r
-  Buffer += Length;\r
-\r
-  Length = sizeof (UINT32);\r
-  CopyMem (Buffer, &Attr, Length);\r
-  Buffer += Length;\r
-\r
-  Length = sizeof (EFI_TIME);\r
-  CopyMem (Buffer, &CertData->TimeStamp, Length);\r
-  Buffer += Length;\r
-\r
-  CopyMem (Buffer, PayloadPtr, PayloadSize);\r
-\r
-  if (AuthVarType == AuthVarTypePk) {\r
-    //\r
-    // Verify that the signature has been made with the current Platform Key (no chaining for PK).\r
-    // First, get signer's certificates from SignedData.\r
-    //\r
-    VerifyStatus = Pkcs7GetSigners (\r
-                     SigData,\r
-                     SigDataSize,\r
-                     &SignerCerts,\r
-                     &CertStackSize,\r
-                     &RootCert,\r
-                     &RootCertSize\r
-                     );\r
-    if (!VerifyStatus) {\r
-      goto Exit;\r
-    }\r
-\r
-    //\r
-    // Second, get the current platform key from variable. Check whether it's identical with signer's certificates\r
-    // in SignedData. If not, return error immediately.\r
-    //\r
-    Status = FindVariable (\r
-               EFI_PLATFORM_KEY_NAME,\r
-               &gEfiGlobalVariableGuid,\r
-               &PkVariable,\r
-               &mVariableModuleGlobal->VariableGlobal,\r
-               FALSE\r
-               );\r
-    if (EFI_ERROR (Status)) {\r
-      VerifyStatus = FALSE;\r
-      goto Exit;\r
-    }\r
-    CertList = (EFI_SIGNATURE_LIST *) GetVariableDataPtr (PkVariable.CurrPtr);\r
-    Cert     = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
-    if ((RootCertSize != (CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1))) ||\r
-        (CompareMem (Cert->SignatureData, RootCert, RootCertSize) != 0)) {\r
-      VerifyStatus = FALSE;\r
-      goto Exit;\r
-    }\r
-\r
-    //\r
-    // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
-    //\r
-    VerifyStatus = Pkcs7Verify (\r
-                     SigData,\r
-                     SigDataSize,\r
-                     RootCert,\r
-                     RootCertSize,\r
-                     NewData,\r
-                     NewDataSize\r
-                     );\r
-\r
-  } else if (AuthVarType == AuthVarTypeKek) {\r
-\r
-    //\r
-    // Get KEK database from variable.\r
-    //\r
-    Status = FindVariable (\r
-               EFI_KEY_EXCHANGE_KEY_NAME,\r
-               &gEfiGlobalVariableGuid,\r
-               &KekVariable,\r
-               &mVariableModuleGlobal->VariableGlobal,\r
-               FALSE\r
-               );\r
-    if (EFI_ERROR (Status)) {\r
-      return Status;\r
-    }\r
-\r
-    //\r
-    // Ready to verify Pkcs7 SignedData. Go through KEK Signature Database to find out X.509 CertList.\r
-    //\r
-    KekDataSize      = KekVariable.CurrPtr->DataSize;\r
-    CertList         = (EFI_SIGNATURE_LIST *) GetVariableDataPtr (KekVariable.CurrPtr);\r
-    while ((KekDataSize > 0) && (KekDataSize >= CertList->SignatureListSize)) {\r
-      if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {\r
-        Cert       = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
-        CertCount  = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
-        for (Index = 0; Index < CertCount; Index++) {\r
-          //\r
-          // Iterate each Signature Data Node within this CertList for a verify\r
-          //\r
-          RootCert      = Cert->SignatureData;\r
-          RootCertSize  = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
-\r
-          //\r
-          // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
-          //\r
-          VerifyStatus = Pkcs7Verify (\r
-                           SigData,\r
-                           SigDataSize,\r
-                           RootCert,\r
-                           RootCertSize,\r
-                           NewData,\r
-                           NewDataSize\r
-                           );\r
-          if (VerifyStatus) {\r
-            goto Exit;\r
-          }\r
-          Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
-        }\r
-      }\r
-      KekDataSize -= CertList->SignatureListSize;\r
-      CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
-    }\r
-  } else if (AuthVarType == AuthVarTypePriv) {\r
-\r
-    //\r
-    // Process common authenticated variable except PK/KEK/DB/DBX/DBT.\r
-    // Get signer's certificates from SignedData.\r
-    //\r
-    VerifyStatus = Pkcs7GetSigners (\r
-                     SigData,\r
-                     SigDataSize,\r
-                     &SignerCerts,\r
-                     &CertStackSize,\r
-                     &RootCert,\r
-                     &RootCertSize\r
-                     );\r
-    if (!VerifyStatus) {\r
-      goto Exit;\r
-    }\r
-\r
-    //\r
-    // Get previously stored signer's certificates from certdb for existing\r
-    // variable. Check whether they are identical with signer's certificates\r
-    // in SignedData. If not, return error immediately.\r
-    //\r
-    if ((Variable->CurrPtr != NULL)) {\r
-      VerifyStatus = FALSE;\r
-\r
-      Status = GetCertsFromDb (VariableName, VendorGuid, &CertsInCertDb, &CertsSizeinDb);\r
-      if (EFI_ERROR (Status)) {\r
-        goto Exit;\r
-      }\r
-\r
-      if ((CertStackSize != CertsSizeinDb) ||\r
-          (CompareMem (SignerCerts, CertsInCertDb, CertsSizeinDb) != 0)) {\r
-        goto Exit;\r
-      }\r
-    }\r
-\r
-    VerifyStatus = Pkcs7Verify (\r
-                     SigData,\r
-                     SigDataSize,\r
-                     RootCert,\r
-                     RootCertSize,\r
-                     NewData,\r
-                     NewDataSize\r
-                     );\r
-    if (!VerifyStatus) {\r
-      goto Exit;\r
-    }\r
-\r
-    //\r
-    // Delete signer's certificates when delete the common authenticated variable.\r
-    //\r
-    if ((PayloadSize == 0) && (Variable->CurrPtr != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
-      Status = DeleteCertsFromDb (VariableName, VendorGuid);\r
-      if (EFI_ERROR (Status)) {\r
-        VerifyStatus = FALSE;\r
-        goto Exit;\r
-      }\r
-    } else if (Variable->CurrPtr == NULL && PayloadSize != 0) {\r
-      //\r
-      // Insert signer's certificates when adding a new common authenticated variable.\r
-      //\r
-      Status = InsertCertsToDb (VariableName, VendorGuid, SignerCerts, CertStackSize);\r
-      if (EFI_ERROR (Status)) {\r
-        VerifyStatus = FALSE;\r
-        goto Exit;\r
-      }\r
-    }\r
-  } else if (AuthVarType == AuthVarTypePayload) {\r
-    CertList = (EFI_SIGNATURE_LIST *) PayloadPtr;\r
-    Cert     = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
-    RootCert      = Cert->SignatureData;\r
-    RootCertSize  = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
-\r
-    // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
-    //\r
-    VerifyStatus = Pkcs7Verify (\r
-                     SigData,\r
-                     SigDataSize,\r
-                     RootCert,\r
-                     RootCertSize,\r
-                     NewData,\r
-                     NewDataSize\r
-                     );\r
-  } else {\r
-    return EFI_SECURITY_VIOLATION;\r
-  }\r
-\r
-Exit:\r
-\r
-  if (AuthVarType == AuthVarTypePk || AuthVarType == AuthVarTypePriv) {\r
-    Pkcs7FreeSigners (RootCert);\r
-    Pkcs7FreeSigners (SignerCerts);\r
-  }\r
-\r
-  if (!VerifyStatus) {\r
-    return EFI_SECURITY_VIOLATION;\r
-  }\r
-\r
-  Status = CheckSignatureListFormat(VariableName, VendorGuid, PayloadPtr, PayloadSize);\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  if ((PayloadSize == 0) && (VarDel != NULL)) {\r
-    *VarDel = TRUE;\r
-  }\r
-\r
-  //\r
-  // Final step: Update/Append Variable if it pass Pkcs7Verify\r
-  //\r
-  return UpdateVariable (\r
-           VariableName,\r
-           VendorGuid,\r
-           PayloadPtr,\r
-           PayloadSize,\r
-           Attributes,\r
-           0,\r
-           0,\r
-           Variable,\r
-           &CertData->TimeStamp\r
-           );\r
-}\r
diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.h b/SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.h
deleted file mode 100644 (file)
index 56def50..0000000
+++ /dev/null
@@ -1,360 +0,0 @@
-/** @file\r
-  The internal header file includes the common header files, defines\r
-  internal structure and functions used by AuthService module.\r
-\r
-  Caution: This module requires additional review when modified.\r
-  This driver will have external input - variable data. It may be input in SMM mode.\r
-  This external input must be validated carefully to avoid security issue like\r
-  buffer overflow, integer overflow.\r
-  Variable attribute should also be checked to avoid authentication bypass.\r
-     The whole SMM authentication variable design relies on the integrity of flash part and SMM.\r
-  which is assumed to be protected by platform.  All variable code and metadata in flash/SMM Memory\r
-  may not be modified without authorization. If platform fails to protect these resources, \r
-  the authentication service provided in this driver will be broken, and the behavior is undefined.\r
-\r
-Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials\r
-are licensed and made available under the terms and conditions of the BSD License\r
-which accompanies this distribution.  The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#ifndef _AUTHSERVICE_H_\r
-#define _AUTHSERVICE_H_\r
-\r
-#define EFI_CERT_TYPE_RSA2048_SHA256_SIZE 256\r
-#define EFI_CERT_TYPE_RSA2048_SIZE        256\r
-\r
-///\r
-/// Size of AuthInfo prior to the data payload.\r
-///\r
-#define AUTHINFO_SIZE ((OFFSET_OF (EFI_VARIABLE_AUTHENTICATION, AuthInfo)) + \\r
-                       (OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData)) + \\r
-                       sizeof (EFI_CERT_BLOCK_RSA_2048_SHA256))\r
-\r
-#define AUTHINFO2_SIZE(VarAuth2) ((OFFSET_OF (EFI_VARIABLE_AUTHENTICATION_2, AuthInfo)) + \\r
-                                  (UINTN) ((EFI_VARIABLE_AUTHENTICATION_2 *) (VarAuth2))->AuthInfo.Hdr.dwLength)\r
-\r
-#define OFFSET_OF_AUTHINFO2_CERT_DATA ((OFFSET_OF (EFI_VARIABLE_AUTHENTICATION_2, AuthInfo)) + \\r
-                                       (OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData)))\r
-\r
-///\r
-/// "AuthVarKeyDatabase" variable for the Public Key store.\r
-///\r
-#define AUTHVAR_KEYDB_NAME      L"AuthVarKeyDatabase"\r
-\r
-///\r
-/// "certdb" variable stores the signer's certificates for non PK/KEK/DB/DBX\r
-/// variables with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set.\r
-/// \r
-///\r
-#define EFI_CERT_DB_NAME        L"certdb"\r
-\r
-///\r
-/// Struct to record signature requirement defined by UEFI spec.\r
-/// For SigHeaderSize and SigDataSize, ((UINT32) ~0) means NO exact length requirement for this field.\r
-///\r
-typedef struct {\r
-  EFI_GUID    SigType;\r
-  // Expected SignatureHeader size in Bytes.\r
-  UINT32      SigHeaderSize;\r
-  // Expected SignatureData size in Bytes.\r
-  UINT32      SigDataSize;\r
-} EFI_SIGNATURE_ITEM;\r
-\r
-typedef enum {\r
-  AuthVarTypePk,\r
-  AuthVarTypeKek,\r
-  AuthVarTypePriv,\r
-  AuthVarTypePayload\r
-} AUTHVAR_TYPE;\r
-\r
-#pragma pack(1)\r
-typedef struct {\r
-  EFI_GUID    VendorGuid;\r
-  UINT32      CertNodeSize;\r
-  UINT32      NameSize;\r
-  UINT32      CertDataSize;\r
-  /// CHAR16  VariableName[NameSize];\r
-  /// UINT8   CertData[CertDataSize];\r
-} AUTH_CERT_DB_DATA;\r
-#pragma pack()\r
-\r
-/**\r
-  Process variable with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS/EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set.\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-  This function will check attribute carefully to avoid authentication bypass.\r
-\r
-  @param[in]  VariableName                Name of Variable to be found.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-\r
-  @param[in]  Data                        Data pointer.\r
-  @param[in]  DataSize                    Size of Data found. If size is less than the\r
-                                          data, this value contains the required size.\r
-  @param[in]  Variable                    The variable information which is used to keep track of variable usage.\r
-  @param[in]  Attributes                  Attribute value of the variable.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid parameter\r
-  @return EFI_WRITE_PROTECTED             Variable is write-protected and needs authentication with\r
-                                          EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS set.\r
-  @return EFI_SECURITY_VIOLATION          The variable is with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS\r
-                                          set, but the AuthInfo does NOT pass the validation\r
-                                          check carried out by the firmware.\r
-  @return EFI_SUCCESS                     Variable is not write-protected, or passed validation successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-ProcessVariable (\r
-  IN     CHAR16                             *VariableName,\r
-  IN     EFI_GUID                           *VendorGuid,\r
-  IN     VOID                               *Data,\r
-  IN     UINTN                              DataSize,\r
-  IN     VARIABLE_POINTER_TRACK             *Variable,\r
-  IN     UINT32                             Attributes\r
-  );\r
-\r
-/**\r
-  Update platform mode.\r
-\r
-  @param[in]      Mode                    SETUP_MODE or USER_MODE.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid parameter.\r
-  @return EFI_SUCCESS                     Update platform mode successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-UpdatePlatformMode (\r
-  IN  UINT32                    Mode\r
-  );\r
-\r
-/**\r
-  Initializes for authenticated varibale service.\r
-\r
-  @param[in] MaxAuthVariableSize    Reflect the overhead associated with the saving\r
-                                    of a single EFI authenticated variable with the exception\r
-                                    of the overhead associated with the length\r
-                                    of the string name of the EFI variable.\r
-\r
-  @retval EFI_SUCCESS           Function successfully executed.\r
-  @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resources.\r
-\r
-**/\r
-EFI_STATUS\r
-AutenticatedVariableServiceInitialize (\r
-  IN UINTN      MaxAuthVariableSize\r
-  );\r
-\r
-/**\r
-  Initializes for cryptlib service before use, include register algrithm and allocate scratch.\r
-\r
-**/\r
-VOID\r
-CryptLibraryInitialize (\r
-  VOID\r
-  );\r
-\r
-/**\r
-  Check input data form to make sure it is a valid EFI_SIGNATURE_LIST for PK/KEK variable.\r
-\r
-  @param[in]  VariableName                Name of Variable to be check.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-  @param[in]  Data                        Point to the variable data to be checked.\r
-  @param[in]  DataSize                    Size of Data.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid signature list format.\r
-  @return EFI_SUCCESS                     Passed signature list format check successfully.\r
-  \r
-**/\r
-EFI_STATUS\r
-CheckSignatureListFormat(\r
-  IN  CHAR16                    *VariableName,\r
-  IN  EFI_GUID                  *VendorGuid,\r
-  IN  VOID                      *Data,\r
-  IN  UINTN                     DataSize\r
-  );\r
-\r
-/**\r
-  Process variable with platform key for verification.\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-  This function will check attribute carefully to avoid authentication bypass.\r
-\r
-  @param[in]  VariableName                Name of Variable to be found.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-  @param[in]  Data                        Data pointer.\r
-  @param[in]  DataSize                    Size of Data found. If size is less than the\r
-                                          data, this value contains the required size.\r
-  @param[in]  Variable                    The variable information which is used to keep track of variable usage.\r
-  @param[in]  Attributes                  Attribute value of the variable.\r
-  @param[in]  IsPk                        Indicate whether it is to process pk.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid parameter\r
-  @return EFI_SECURITY_VIOLATION          The variable does NOT pass the validation\r
-                                          check carried out by the firmware.\r
-  @return EFI_SUCCESS                     Variable passed validation successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-ProcessVarWithPk (\r
-  IN  CHAR16                    *VariableName,\r
-  IN  EFI_GUID                  *VendorGuid,\r
-  IN  VOID                      *Data,\r
-  IN  UINTN                     DataSize,\r
-  IN  VARIABLE_POINTER_TRACK    *Variable,\r
-  IN  UINT32                    Attributes OPTIONAL,\r
-  IN  BOOLEAN                   IsPk\r
-  );\r
-\r
-/**\r
-  Process variable with key exchange key for verification.\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-  This function will check attribute carefully to avoid authentication bypass.\r
-\r
-  @param[in]  VariableName                Name of Variable to be found.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-  @param[in]  Data                        Data pointer.\r
-  @param[in]  DataSize                    Size of Data found. If size is less than the\r
-                                          data, this value contains the required size.\r
-  @param[in]  Variable                    The variable information that is used to keep track of variable usage.\r
-  @param[in]  Attributes                  Attribute value of the variable.\r
-\r
-  @return EFI_INVALID_PARAMETER           Invalid parameter.\r
-  @return EFI_SECURITY_VIOLATION          The variable does NOT pass the validation\r
-                                          check carried out by the firmware.\r
-  @return EFI_SUCCESS                     Variable passed validation successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-ProcessVarWithKek (\r
-  IN  CHAR16                    *VariableName,\r
-  IN  EFI_GUID                  *VendorGuid,\r
-  IN  VOID                      *Data,\r
-  IN  UINTN                     DataSize,\r
-  IN  VARIABLE_POINTER_TRACK    *Variable,\r
-  IN  UINT32                    Attributes OPTIONAL\r
-  );\r
-\r
-/**\r
-  Merge two buffers which formatted as EFI_SIGNATURE_LIST. Only the new EFI_SIGNATURE_DATA\r
-  will be appended to the original EFI_SIGNATURE_LIST, duplicate EFI_SIGNATURE_DATA\r
-  will be ignored.\r
-\r
-  @param[in, out]  Data             Pointer to original EFI_SIGNATURE_LIST.\r
-  @param[in]       DataSize         Size of Data buffer.\r
-  @param[in]       FreeBufSize      Size of free data buffer \r
-  @param[in]       NewData          Pointer to new EFI_SIGNATURE_LIST to be appended.\r
-  @param[in]       NewDataSize      Size of NewData buffer.\r
-  @param[out]      MergedBufSize    Size of the merged buffer\r
-\r
-  @return EFI_BUFFER_TOO_SMALL if input Data buffer overflowed\r
-\r
-**/\r
-EFI_STATUS\r
-AppendSignatureList (\r
-  IN  OUT VOID            *Data,\r
-  IN  UINTN               DataSize,\r
-  IN  UINTN               FreeBufSize,\r
-  IN  VOID                *NewData,\r
-  IN  UINTN               NewDataSize,\r
-  OUT UINTN               *MergedBufSize\r
-  );\r
-\r
-/**\r
-  Compare two EFI_TIME data.\r
-\r
-\r
-  @param FirstTime           A pointer to the first EFI_TIME data.\r
-  @param SecondTime          A pointer to the second EFI_TIME data.\r
-\r
-  @retval  TRUE              The FirstTime is not later than the SecondTime.\r
-  @retval  FALSE             The FirstTime is later than the SecondTime.\r
-\r
-**/\r
-BOOLEAN\r
-CompareTimeStamp (\r
-  IN EFI_TIME               *FirstTime,\r
-  IN EFI_TIME               *SecondTime\r
-  );\r
-\r
-/**\r
-  Delete matching signer's certificates when deleting common authenticated\r
-  variable by corresponding VariableName and VendorGuid from "certdb".\r
-\r
-  @param[in]  VariableName   Name of authenticated Variable.\r
-  @param[in]  VendorGuid     Vendor GUID of authenticated Variable.\r
-\r
-  @retval  EFI_INVALID_PARAMETER Any input parameter is invalid.\r
-  @retval  EFI_NOT_FOUND         Fail to find "certdb" or matching certs.\r
-  @retval  EFI_OUT_OF_RESOURCES  The operation is failed due to lack of resources.\r
-  @retval  EFI_SUCCESS           The operation is completed successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-DeleteCertsFromDb (\r
-  IN     CHAR16           *VariableName,\r
-  IN     EFI_GUID         *VendorGuid\r
-  );\r
-\r
-/**\r
-  Process variable with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
-\r
-  Caution: This function may receive untrusted input.\r
-  This function may be invoked in SMM mode, and datasize and data are external input.\r
-  This function will do basic validation, before parse the data.\r
-  This function will parse the authentication carefully to avoid security issues, like\r
-  buffer overflow, integer overflow.\r
-\r
-  @param[in]  VariableName                Name of Variable to be found.\r
-  @param[in]  VendorGuid                  Variable vendor GUID.\r
-  @param[in]  Data                        Data pointer.\r
-  @param[in]  DataSize                    Size of Data found. If size is less than the\r
-                                          data, this value contains the required size.\r
-  @param[in]  Variable                    The variable information which is used to keep track of variable usage.\r
-  @param[in]  Attributes                  Attribute value of the variable.\r
-  @param[in]  AuthVarType                 Verify against PK or KEK database or private database.\r
-  @param[out] VarDel                      Delete the variable or not.\r
-\r
-  @retval EFI_INVALID_PARAMETER           Invalid parameter.\r
-  @retval EFI_SECURITY_VIOLATION          The variable does NOT pass the validation\r
-                                          check carried out by the firmware.\r
-  @retval EFI_OUT_OF_RESOURCES            Failed to process variable due to lack\r
-                                          of resources.\r
-  @retval EFI_SUCCESS                     Variable pass validation successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-VerifyTimeBasedPayload (\r
-  IN     CHAR16                             *VariableName,\r
-  IN     EFI_GUID                           *VendorGuid,\r
-  IN     VOID                               *Data,\r
-  IN     UINTN                              DataSize,\r
-  IN     VARIABLE_POINTER_TRACK             *Variable,\r
-  IN     UINT32                             Attributes,\r
-  IN     AUTHVAR_TYPE                       AuthVarType,\r
-  OUT    BOOLEAN                            *VarDel\r
-  );\r
-\r
-extern UINT8  *mPubKeyStore;\r
-extern UINT8  *mCertDbStore;\r
-extern UINT32 mPubKeyNumber;\r
-extern VOID   *mHashCtx;\r
-\r
-#endif\r
diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/Measurement.c b/SecurityPkg/VariableAuthenticated/RuntimeDxe/Measurement.c
deleted file mode 100644 (file)
index 1b625e7..0000000
+++ /dev/null
@@ -1,255 +0,0 @@
-/** @file\r
-  Measure TrEE required variable.\r
-\r
-Copyright (c) 2013 - 2014, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials\r
-are licensed and made available under the terms and conditions of the BSD License\r
-which accompanies this distribution.  The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#include <PiDxe.h>\r
-#include <Guid/ImageAuthentication.h>\r
-#include <IndustryStandard/UefiTcgPlatform.h>\r
-#include <Protocol/TrEEProtocol.h>\r
-\r
-#include <Library/UefiBootServicesTableLib.h>\r
-#include <Library/UefiRuntimeServicesTableLib.h>\r
-#include <Library/MemoryAllocationLib.h>\r
-#include <Library/BaseMemoryLib.h>\r
-#include <Library/DebugLib.h>\r
-#include <Library/BaseLib.h>\r
-#include <Library/TpmMeasurementLib.h>\r
-\r
-typedef struct {\r
-  CHAR16                                 *VariableName;\r
-  EFI_GUID                               *VendorGuid;\r
-} VARIABLE_TYPE;\r
-\r
-VARIABLE_TYPE  mVariableType[] = {\r
-  {EFI_SECURE_BOOT_MODE_NAME,    &gEfiGlobalVariableGuid},\r
-  {EFI_PLATFORM_KEY_NAME,        &gEfiGlobalVariableGuid},\r
-  {EFI_KEY_EXCHANGE_KEY_NAME,    &gEfiGlobalVariableGuid},\r
-  {EFI_IMAGE_SECURITY_DATABASE,  &gEfiImageSecurityDatabaseGuid},\r
-  {EFI_IMAGE_SECURITY_DATABASE1, &gEfiImageSecurityDatabaseGuid},\r
-};\r
-\r
-/**\r
-  This function will return if this variable is SecureBootPolicy Variable.\r
-\r
-  @param[in]  VariableName      A Null-terminated string that is the name of the vendor's variable.\r
-  @param[in]  VendorGuid        A unique identifier for the vendor.\r
-\r
-  @retval TRUE  This is SecureBootPolicy Variable\r
-  @retval FALSE This is not SecureBootPolicy Variable\r
-**/\r
-BOOLEAN\r
-IsSecureBootPolicyVariable (\r
-  IN CHAR16                                 *VariableName,\r
-  IN EFI_GUID                               *VendorGuid\r
-  )\r
-{\r
-  UINTN   Index;\r
-\r
-  for (Index = 0; Index < sizeof(mVariableType)/sizeof(mVariableType[0]); Index++) {\r
-    if ((StrCmp (VariableName, mVariableType[Index].VariableName) == 0) && \r
-        (CompareGuid (VendorGuid, mVariableType[Index].VendorGuid))) {\r
-      return TRUE;\r
-    }\r
-  }\r
-  return FALSE;\r
-}\r
-\r
-/**\r
-  Measure and log an EFI variable, and extend the measurement result into a specific PCR.\r
-\r
-  @param[in]  VarName           A Null-terminated string that is the name of the vendor's variable.\r
-  @param[in]  VendorGuid        A unique identifier for the vendor.\r
-  @param[in]  VarData           The content of the variable data.  \r
-  @param[in]  VarSize           The size of the variable data.  \r
\r
-  @retval EFI_SUCCESS           Operation completed successfully.\r
-  @retval EFI_OUT_OF_RESOURCES  Out of memory.\r
-  @retval EFI_DEVICE_ERROR      The operation was unsuccessful.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-MeasureVariable (\r
-  IN      CHAR16                    *VarName,\r
-  IN      EFI_GUID                  *VendorGuid,\r
-  IN      VOID                      *VarData,\r
-  IN      UINTN                     VarSize\r
-  )\r
-{\r
-  EFI_STATUS                        Status;\r
-  UINTN                             VarNameLength;\r
-  EFI_VARIABLE_DATA_TREE            *VarLog;\r
-  UINT32                            VarLogSize;\r
-\r
-  ASSERT ((VarSize == 0 && VarData == NULL) || (VarSize != 0 && VarData != NULL));\r
-\r
-  VarNameLength      = StrLen (VarName);\r
-  VarLogSize = (UINT32)(sizeof (*VarLog) + VarNameLength * sizeof (*VarName) + VarSize\r
-                        - sizeof (VarLog->UnicodeName) - sizeof (VarLog->VariableData));\r
-\r
-  VarLog = (EFI_VARIABLE_DATA_TREE *) AllocateZeroPool (VarLogSize);\r
-  if (VarLog == NULL) {\r
-    return EFI_OUT_OF_RESOURCES;\r
-  }\r
-\r
-  CopyMem (&VarLog->VariableName, VendorGuid, sizeof(VarLog->VariableName));\r
-  VarLog->UnicodeNameLength  = VarNameLength;\r
-  VarLog->VariableDataLength = VarSize;\r
-  CopyMem (\r
-     VarLog->UnicodeName,\r
-     VarName,\r
-     VarNameLength * sizeof (*VarName)\r
-     );\r
-  if (VarSize != 0) {\r
-    CopyMem (\r
-       (CHAR16 *)VarLog->UnicodeName + VarNameLength,\r
-       VarData,\r
-       VarSize\r
-       );\r
-  }\r
-\r
-  DEBUG ((EFI_D_INFO, "AuthVariableDxe: MeasureVariable (Pcr - %x, EventType - %x, ", (UINTN)7, (UINTN)EV_EFI_VARIABLE_AUTHORITY));\r
-  DEBUG ((EFI_D_INFO, "VariableName - %s, VendorGuid - %g)\n", VarName, VendorGuid));\r
-\r
-  Status = TpmMeasureAndLogData (\r
-             7,\r
-             EV_EFI_VARIABLE_DRIVER_CONFIG,\r
-             VarLog,\r
-             VarLogSize,\r
-             VarLog,\r
-             VarLogSize\r
-             );\r
-  FreePool (VarLog);\r
-  return Status;\r
-}\r
-\r
-/**\r
-  Returns the status whether get the variable success. The function retrieves \r
-  variable  through the UEFI Runtime Service GetVariable().  The \r
-  returned buffer is allocated using AllocatePool().  The caller is responsible\r
-  for freeing this buffer with FreePool().\r
-\r
-  This API is only invoked in boot time. It may NOT be invoked at runtime.\r
-\r
-  @param[in]  Name  The pointer to a Null-terminated Unicode string.\r
-  @param[in]  Guid  The pointer to an EFI_GUID structure\r
-  @param[out] Value The buffer point saved the variable info.\r
-  @param[out] Size  The buffer size of the variable.\r
-\r
-  @return EFI_OUT_OF_RESOURCES      Allocate buffer failed.\r
-  @return EFI_SUCCESS               Find the specified variable.\r
-  @return Others Errors             Return errors from call to gRT->GetVariable.\r
-\r
-**/\r
-EFI_STATUS\r
-InternalGetVariable (\r
-  IN CONST CHAR16    *Name,\r
-  IN CONST EFI_GUID  *Guid,\r
-  OUT VOID           **Value,\r
-  OUT UINTN          *Size\r
-  )\r
-{\r
-  EFI_STATUS  Status;\r
-  UINTN       BufferSize;\r
-\r
-  //\r
-  // Try to get the variable size.\r
-  //\r
-  BufferSize = 0;\r
-  *Value     = NULL;\r
-  if (Size != NULL) {\r
-    *Size  = 0;\r
-  }\r
-  \r
-  Status = gRT->GetVariable ((CHAR16 *) Name, (EFI_GUID *) Guid, NULL, &BufferSize, *Value);\r
-  if (Status != EFI_BUFFER_TOO_SMALL) {\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // Allocate buffer to get the variable.\r
-  //\r
-  *Value = AllocatePool (BufferSize);\r
-  ASSERT (*Value != NULL);\r
-  if (*Value == NULL) {\r
-    return EFI_OUT_OF_RESOURCES;\r
-  }\r
-\r
-  //\r
-  // Get the variable data.\r
-  //\r
-  Status = gRT->GetVariable ((CHAR16 *) Name, (EFI_GUID *) Guid, NULL, &BufferSize, *Value);\r
-  if (EFI_ERROR (Status)) {\r
-    FreePool(*Value);\r
-    *Value = NULL;\r
-  }\r
-\r
-  if (Size != NULL) {\r
-    *Size = BufferSize;\r
-  }\r
-\r
-  return Status;\r
-}\r
-\r
-/**\r
-  SecureBoot Hook for SetVariable.\r
-\r
-  @param[in] VariableName                 Name of Variable to be found.\r
-  @param[in] VendorGuid                   Variable vendor GUID.\r
-\r
-**/\r
-VOID\r
-EFIAPI\r
-SecureBootHook (\r
-  IN CHAR16                                 *VariableName,\r
-  IN EFI_GUID                               *VendorGuid\r
-  )\r
-{\r
-  EFI_STATUS                        Status;\r
-  UINTN                             VariableDataSize;\r
-  VOID                              *VariableData;\r
-\r
-  if (!IsSecureBootPolicyVariable (VariableName, VendorGuid)) {\r
-    return ;\r
-  }\r
-\r
-  //\r
-  // We should NOT use Data and DataSize here,because it may include signature,\r
-  // or is just partial with append attributes, or is deleted.\r
-  // We should GetVariable again, to get full variable content.\r
-  //\r
-  Status = InternalGetVariable (\r
-             VariableName,\r
-             VendorGuid,\r
-             &VariableData,\r
-             &VariableDataSize\r
-             );\r
-  if (EFI_ERROR (Status)) {\r
-    VariableData     = NULL;\r
-    VariableDataSize = 0;\r
-  }\r
-\r
-  Status = MeasureVariable (\r
-             VariableName,\r
-             VendorGuid,\r
-             VariableData,\r
-             VariableDataSize\r
-             );\r
-  DEBUG ((EFI_D_INFO, "MeasureBootPolicyVariable - %r\n", Status));\r
-\r
-  if (VariableData != NULL) {\r
-    FreePool (VariableData);\r
-  }\r
-\r
-  return ;\r
-}\r
diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/Reclaim.c b/SecurityPkg/VariableAuthenticated/RuntimeDxe/Reclaim.c
deleted file mode 100644 (file)
index d79cd36..0000000
+++ /dev/null
@@ -1,161 +0,0 @@
-/** @file\r
-  Handles non-volatile variable store garbage collection, using FTW\r
-  (Fault Tolerant Write) protocol.\r
-\r
-Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials \r
-are licensed and made available under the terms and conditions of the BSD License \r
-which accompanies this distribution.  The full text of the license may be found at \r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#include "Variable.h"\r
-\r
-/**\r
-  Gets LBA of block and offset by given address.\r
-\r
-  This function gets the Logical Block Address (LBA) of a firmware\r
-  volume block containing the given address, and the offset of the\r
-  address on the block.\r
-\r
-  @param  Address        Address which should be contained\r
-                         by returned FVB handle.\r
-  @param  Lba            Pointer to LBA for output.\r
-  @param  Offset         Pointer to offset for output.\r
-\r
-  @retval EFI_SUCCESS    LBA and offset successfully returned.\r
-  @retval EFI_NOT_FOUND  Fail to find FVB handle by address.\r
-  @retval EFI_ABORTED    Fail to find valid LBA and offset.\r
-\r
-**/\r
-EFI_STATUS\r
-GetLbaAndOffsetByAddress (\r
-  IN  EFI_PHYSICAL_ADDRESS   Address,\r
-  OUT EFI_LBA                *Lba,\r
-  OUT UINTN                  *Offset\r
-  )\r
-{\r
-  EFI_STATUS                          Status;\r
-  EFI_PHYSICAL_ADDRESS                FvbBaseAddress;\r
-  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;\r
-  EFI_FIRMWARE_VOLUME_HEADER          *FwVolHeader;\r
-  EFI_FV_BLOCK_MAP_ENTRY              *FvbMapEntry;\r
-  UINT32                              LbaIndex;\r
-\r
-  *Lba    = (EFI_LBA) (-1);\r
-  *Offset = 0;\r
-  Fvb = NULL;\r
-\r
-  //\r
-  // Get the proper FVB protocol.\r
-  //\r
-  Status = GetFvbInfoByAddress (Address, NULL, &Fvb);\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  //\r
-  // Get the Base Address of FV.\r
-  //\r
-  Status = Fvb->GetPhysicalAddress (Fvb, &FvbBaseAddress);\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-\r
-  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvbBaseAddress);\r
-\r
-  //\r
-  // Get the (LBA, Offset) of Address.\r
-  //\r
-  if ((FwVolHeader->FvLength) > (FwVolHeader->HeaderLength)) {\r
-    //\r
-    // BUGBUG: Assume one FV has one type of BlockLength.\r
-    //\r
-    FvbMapEntry = &FwVolHeader->BlockMap[0];\r
-    for (LbaIndex = 1; LbaIndex <= FvbMapEntry->NumBlocks; LbaIndex += 1) {\r
-      if (Address < (FvbBaseAddress + FvbMapEntry->Length * LbaIndex)) {\r
-        //\r
-        // Found the (Lba, Offset).\r
-        //\r
-        *Lba    = LbaIndex - 1;\r
-        *Offset = (UINTN) (Address - (FvbBaseAddress + FvbMapEntry->Length * (LbaIndex - 1)));\r
-        return EFI_SUCCESS;\r
-     }\r
-    }\r
-  }\r
-\r
-  return EFI_ABORTED;\r
-}\r
-\r
-/**\r
-  Writes a buffer to variable storage space, in the working block.\r
-\r
-  This function writes a buffer to variable storage space into a firmware\r
-  volume block device. The destination is specified by parameter\r
-  VariableBase. Fault Tolerant Write protocol is used for writing.\r
-\r
-  @param  VariableBase   Base address of variable to write\r
-  @param  VariableBuffer Point to the variable data buffer.\r
-\r
-  @retval EFI_SUCCESS    The function completed successfully.\r
-  @retval EFI_NOT_FOUND  Fail to locate Fault Tolerant Write protocol.\r
-  @retval EFI_ABORTED    The function could not complete successfully.\r
-\r
-**/\r
-EFI_STATUS\r
-FtwVariableSpace (\r
-  IN EFI_PHYSICAL_ADDRESS   VariableBase,\r
-  IN VARIABLE_STORE_HEADER  *VariableBuffer\r
-  )\r
-{\r
-  EFI_STATUS                         Status;\r
-  EFI_HANDLE                         FvbHandle;\r
-  EFI_LBA                            VarLba;\r
-  UINTN                              VarOffset;\r
-  UINTN                              FtwBufferSize;\r
-  EFI_FAULT_TOLERANT_WRITE_PROTOCOL  *FtwProtocol;\r
-\r
-  //\r
-  // Locate fault tolerant write protocol.\r
-  //\r
-  Status = GetFtwProtocol((VOID **) &FtwProtocol);\r
-  if (EFI_ERROR (Status)) {\r
-    return EFI_NOT_FOUND;\r
-  }\r
-  //\r
-  // Locate Fvb handle by address.\r
-  //\r
-  Status = GetFvbInfoByAddress (VariableBase, &FvbHandle, NULL);\r
-  if (EFI_ERROR (Status)) {\r
-    return Status;\r
-  }\r
-  //\r
-  // Get LBA and Offset by address.\r
-  //\r
-  Status = GetLbaAndOffsetByAddress (VariableBase, &VarLba, &VarOffset);\r
-  if (EFI_ERROR (Status)) {\r
-    return EFI_ABORTED;\r
-  }\r
-\r
-  FtwBufferSize = ((VARIABLE_STORE_HEADER *) ((UINTN) VariableBase))->Size;\r
-  ASSERT (FtwBufferSize == VariableBuffer->Size);\r
-\r
-  //\r
-  // FTW write record.\r
-  //\r
-  Status = FtwProtocol->Write (\r
-                          FtwProtocol,\r
-                          VarLba,         // LBA\r
-                          VarOffset,      // Offset\r
-                          FtwBufferSize,  // NumBytes\r
-                          NULL,           // PrivateData NULL\r
-                          FvbHandle,      // Fvb Handle\r
-                          (VOID *) VariableBuffer // write buffer\r
-                          );\r
-\r
-  return Status;\r
-}\r
diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/VarCheck.c b/SecurityPkg/VariableAuthenticated/RuntimeDxe/VarCheck.c
deleted file mode 100644 (file)
index 740632f..0000000
+++ /dev/null
@@ -1,1264 +0,0 @@
-/** @file\r
-  Implementation functions and structures for var check protocol.\r
-\r
-Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
-This program and the accompanying materials \r
-are licensed and made available under the terms and conditions of the BSD License \r
-which accompanies this distribution.  The full text of the license may be found at \r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#include "Variable.h"\r
-#include "AuthService.h"\r
-#include <Library/DevicePathLib.h>\r
-\r
-extern LIST_ENTRY mLockedVariableList;\r
-extern BOOLEAN mEndOfDxe;\r
-extern BOOLEAN mEnableLocking;\r
-\r
-#define VAR_CHECK_HANDLER_TABLE_SIZE    0x8\r
-\r
-UINT32                                  mNumberOfHandler = 0;\r
-UINT32                                  mMaxNumberOfHandler = 0;\r
-VAR_CHECK_SET_VARIABLE_CHECK_HANDLER    *mHandlerTable = NULL;\r
-\r
-typedef struct {\r
-  LIST_ENTRY                    Link;\r
-  EFI_GUID                      Guid;\r
-  VAR_CHECK_VARIABLE_PROPERTY   VariableProperty;\r
-  //CHAR16                        *Name;\r
-} VAR_CHECK_VARIABLE_ENTRY;\r
-\r
-LIST_ENTRY mVarCheckVariableList = INITIALIZE_LIST_HEAD_VARIABLE (mVarCheckVariableList);\r
-\r
-typedef\r
-EFI_STATUS\r
-(EFIAPI *INTERNAL_VAR_CHECK_FUNCTION) (\r
-  IN VAR_CHECK_VARIABLE_PROPERTY    *Propery,\r
-  IN UINTN                          DataSize,\r
-  IN VOID                           *Data\r
-  );\r
-\r
-typedef struct {\r
-  CHAR16                        *Name;\r
-  VAR_CHECK_VARIABLE_PROPERTY   VariableProperty;\r
-  INTERNAL_VAR_CHECK_FUNCTION   CheckFunction;\r
-} UEFI_DEFINED_VARIABLE_ENTRY;\r
-\r
-/**\r
-  Internal check for load option.\r
-\r
-  @param[in] VariablePropery    Pointer to variable property.\r
-  @param[in] DataSize           Data size.\r
-  @param[in] Data               Pointer to data buffer.\r
-\r
-  @retval EFI_SUCCESS           The SetVariable check result was success.\r
-  @retval EFI_INVALID_PARAMETER The data buffer is not a valid load option.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-InternalVarCheckLoadOption (\r
-  IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,\r
-  IN UINTN                          DataSize,\r
-  IN VOID                           *Data\r
-  )\r
-{\r
-  UINT16                    FilePathListLength;\r
-  CHAR16                    *Description;\r
-  EFI_DEVICE_PATH_PROTOCOL  *FilePathList;\r
-\r
-  FilePathListLength = *((UINT16 *) ((UINTN) Data + sizeof (UINT32)));\r
-\r
-  //\r
-  // Check Description\r
-  //\r
-  Description = (CHAR16 *) ((UINTN) Data + sizeof (UINT32) + sizeof (UINT16));\r
-  while (Description < (CHAR16 *) ((UINTN) Data + DataSize)) {\r
-    if (*Description == L'\0') {\r
-      break;\r
-    }\r
-    Description++;\r
-  }\r
-  if ((UINTN) Description >= ((UINTN) Data + DataSize)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-  Description++;\r
-\r
-  //\r
-  // Check FilePathList\r
-  //\r
-  FilePathList = (EFI_DEVICE_PATH_PROTOCOL *) Description;\r
-  if ((UINTN) FilePathList > (MAX_ADDRESS - FilePathListLength)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-  if (((UINTN) FilePathList + FilePathListLength) > ((UINTN) Data + DataSize)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-  if (FilePathListLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-  if (!IsDevicePathValid (FilePathList, FilePathListLength)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Internal check for key option.\r
-\r
-  @param[in] VariablePropery    Pointer to variable property.\r
-  @param[in] DataSize           Data size.\r
-  @param[in] Data               Pointer to data buffer.\r
-\r
-  @retval EFI_SUCCESS           The SetVariable check result was success.\r
-  @retval EFI_INVALID_PARAMETER The data buffer is not a valid key option.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-InternalVarCheckKeyOption (\r
-  IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,\r
-  IN UINTN                          DataSize,\r
-  IN VOID                           *Data\r
-  )\r
-{\r
-  if (((DataSize - sizeof (EFI_KEY_OPTION)) % sizeof (EFI_INPUT_KEY)) != 0) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Internal check for device path.\r
-\r
-  @param[in] VariablePropery    Pointer to variable property.\r
-  @param[in] DataSize           Data size.\r
-  @param[in] Data               Pointer to data buffer.\r
-\r
-  @retval EFI_SUCCESS           The SetVariable check result was success.\r
-  @retval EFI_INVALID_PARAMETER The data buffer is not a valid device path.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-InternalVarCheckDevicePath (\r
-  IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,\r
-  IN UINTN                          DataSize,\r
-  IN VOID                           *Data\r
-  )\r
-{\r
-  if (!IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL *) Data, DataSize)) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Internal check for ASCII string.\r
-\r
-  @param[in] VariablePropery    Pointer to variable property.\r
-  @param[in] DataSize           Data size.\r
-  @param[in] Data               Pointer to data buffer.\r
-\r
-  @retval EFI_SUCCESS           The SetVariable check result was success.\r
-  @retval EFI_INVALID_PARAMETER The data buffer is not a Null-terminated ASCII string.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-InternalVarCheckAsciiString (\r
-  IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,\r
-  IN UINTN                          DataSize,\r
-  IN VOID                           *Data\r
-  )\r
-{\r
-  CHAR8     *String;\r
-  UINTN     Index;\r
-\r
-  String = (CHAR8 *) Data;\r
-  if (String[DataSize - 1] == '\0') {\r
-    return EFI_SUCCESS;\r
-  } else {\r
-    for (Index = 1; Index < DataSize && (String[DataSize - 1 - Index] != '\0'); Index++);\r
-    if (Index == DataSize) {\r
-      return EFI_INVALID_PARAMETER;\r
-    }\r
-  }\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Internal check for size array.\r
-\r
-  @param[in] VariablePropery    Pointer to variable property.\r
-  @param[in] DataSize           Data size.\r
-  @param[in] Data               Pointer to data buffer.\r
-\r
-  @retval EFI_SUCCESS           The SetVariable check result was success.\r
-  @retval EFI_INVALID_PARAMETER The DataSize is not size array.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-InternalVarCheckSizeArray (\r
-  IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,\r
-  IN UINTN                          DataSize,\r
-  IN VOID                           *Data\r
-  )\r
-{\r
-  if ((DataSize % VariablePropery->MinSize) != 0) {\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-//\r
-// To prevent name collisions with possible future globally defined variables,\r
-// other internal firmware data variables that are not defined here must be\r
-// saved with a unique VendorGuid other than EFI_GLOBAL_VARIABLE or\r
-// any other GUID defined by the UEFI Specification. Implementations must\r
-// only permit the creation of variables with a UEFI Specification-defined\r
-// VendorGuid when these variables are documented in the UEFI Specification.\r
-//\r
-UEFI_DEFINED_VARIABLE_ENTRY mGlobalVariableList[] = {\r
-  {\r
-    EFI_LANG_CODES_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckAsciiString\r
-  },\r
-  {\r
-    EFI_LANG_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckAsciiString\r
-  },\r
-  {\r
-    EFI_TIME_OUT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT16),\r
-      sizeof (UINT16)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_PLATFORM_LANG_CODES_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckAsciiString\r
-  },\r
-  {\r
-    EFI_PLATFORM_LANG_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckAsciiString\r
-  },\r
-  {\r
-    EFI_CON_IN_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (EFI_DEVICE_PATH_PROTOCOL),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckDevicePath\r
-  },\r
-  {\r
-    EFI_CON_OUT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (EFI_DEVICE_PATH_PROTOCOL),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckDevicePath\r
-  },\r
-  {\r
-    EFI_ERR_OUT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (EFI_DEVICE_PATH_PROTOCOL),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckDevicePath\r
-  },\r
-  {\r
-    EFI_CON_IN_DEV_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (EFI_DEVICE_PATH_PROTOCOL),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckDevicePath\r
-  },\r
-  {\r
-    EFI_CON_OUT_DEV_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (EFI_DEVICE_PATH_PROTOCOL),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckDevicePath\r
-  },\r
-  {\r
-    EFI_ERR_OUT_DEV_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (EFI_DEVICE_PATH_PROTOCOL),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckDevicePath\r
-  },\r
-  {\r
-    EFI_BOOT_ORDER_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT16),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckSizeArray\r
-  },\r
-  {\r
-    EFI_BOOT_NEXT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT16),\r
-      sizeof (UINT16)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_BOOT_CURRENT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (UINT16),\r
-      sizeof (UINT16)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (UINT32),\r
-      sizeof (UINT32)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_DRIVER_ORDER_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT16),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckSizeArray\r
-  },\r
-  {\r
-    EFI_SYS_PREP_ORDER_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT16),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckSizeArray\r
-  },\r
-  {\r
-    EFI_HW_ERR_REC_SUPPORT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT16),\r
-      sizeof (UINT16)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_SETUP_MODE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (UINT8),\r
-      sizeof (UINT8)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_KEY_EXCHANGE_KEY_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT_AT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_PLATFORM_KEY_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT_AT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_SIGNATURE_SUPPORT_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (EFI_GUID),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckSizeArray\r
-  },\r
-  {\r
-    EFI_SECURE_BOOT_MODE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (UINT8),\r
-      sizeof (UINT8)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_KEK_DEFAULT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_PK_DEFAULT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_DB_DEFAULT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_DBX_DEFAULT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_DBT_DEFAULT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (UINT64),\r
-      sizeof (UINT64)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_OS_INDICATIONS_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT64),\r
-      sizeof (UINT64)\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_VENDOR_KEYS_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_BS_RT,\r
-      sizeof (UINT8),\r
-      sizeof (UINT8)\r
-    },\r
-    NULL\r
-  },\r
-};\r
-UEFI_DEFINED_VARIABLE_ENTRY mGlobalVariableList2[] = {\r
-  {\r
-    L"Boot####",\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT32) + sizeof (UINT16),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckLoadOption\r
-  },\r
-  {\r
-    L"Driver####",\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT32) + sizeof (UINT16),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckLoadOption\r
-  },\r
-  {\r
-    L"SysPrep####",\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (UINT32) + sizeof (UINT16),\r
-      MAX_UINTN\r
-    },\r
-    InternalVarCheckLoadOption\r
-  },\r
-  {\r
-    L"Key####",\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (EFI_KEY_OPTION),\r
-      sizeof (EFI_KEY_OPTION) + 3 * sizeof (EFI_INPUT_KEY)\r
-    },\r
-    InternalVarCheckKeyOption\r
-  },\r
-};\r
-\r
-//\r
-// EFI_IMAGE_SECURITY_DATABASE_GUID\r
-//\r
-UEFI_DEFINED_VARIABLE_ENTRY mImageSecurityVariableList[] = {\r
-  {\r
-    EFI_IMAGE_SECURITY_DATABASE,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT_AT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_IMAGE_SECURITY_DATABASE1,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT_AT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-  {\r
-    EFI_IMAGE_SECURITY_DATABASE2,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT_AT,\r
-      1,\r
-      MAX_UINTN\r
-    },\r
-    NULL\r
-  },\r
-};\r
-\r
-typedef struct {\r
-  EFI_GUID                      *Guid;\r
-  CHAR16                        *Name;\r
-  VAR_CHECK_VARIABLE_PROPERTY   VariableProperty;\r
-  INTERNAL_VAR_CHECK_FUNCTION   CheckFunction;\r
-} VARIABLE_DRIVER_VARIABLE_ENTRY;\r
-\r
-VARIABLE_DRIVER_VARIABLE_ENTRY mVariableDriverVariableList[] = {\r
-  {\r
-    &gEfiSecureBootEnableDisableGuid,\r
-    EFI_SECURE_BOOT_ENABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS,\r
-      sizeof (UINT8),\r
-      sizeof (UINT8)\r
-    }\r
-  },\r
-  {\r
-    &gEfiCustomModeEnableGuid,\r
-    EFI_CUSTOM_MODE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      0,\r
-      VARIABLE_ATTRIBUTE_NV_BS,\r
-      sizeof (UINT8),\r
-      sizeof (UINT8)\r
-    }\r
-  },\r
-  {\r
-    &gEfiVendorKeysNvGuid,\r
-    EFI_VENDOR_KEYS_NV_VARIABLE_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT_AT,\r
-      sizeof (UINT8),\r
-      sizeof (UINT8)\r
-    }\r
-  },\r
-  {\r
-    &gEfiAuthenticatedVariableGuid,\r
-    AUTHVAR_KEYDB_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT_AW,\r
-      sizeof (UINT8),\r
-      MAX_UINTN\r
-    }\r
-  },\r
-  {\r
-    &gEfiCertDbGuid,\r
-    EFI_CERT_DB_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT_AT,\r
-      sizeof (UINT32),\r
-      MAX_UINTN\r
-    }\r
-  },\r
-  {\r
-    &gEdkiiVarErrorFlagGuid,\r
-    VAR_ERROR_FLAG_NAME,\r
-    {\r
-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,\r
-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,\r
-      VARIABLE_ATTRIBUTE_NV_BS_RT,\r
-      sizeof (VAR_ERROR_FLAG),\r
-      sizeof (VAR_ERROR_FLAG)\r
-    }\r
-  },\r
-};\r
-\r
-/**\r
-  Get UEFI defined global variable or image security database variable property.\r
-  The code will check if variable guid is global variable or image security database guid first.\r
-  If yes, further check if variable name is in mGlobalVariableList, mGlobalVariableList2 or mImageSecurityVariableList.\r
-\r
-  @param[in]  VariableName      Pointer to variable name.\r
-  @param[in]  VendorGuid        Variable Vendor Guid.\r
-  @param[in]  WildcardMatch     Try wildcard match or not.\r
-  @param[out] VariableProperty  Pointer to variable property.\r
-  @param[out] VarCheckFunction  Pointer to check function.\r
-\r
-  @retval EFI_SUCCESS           Variable is not global variable or image security database variable.\r
-  @retval EFI_INVALID_PARAMETER Variable is global variable or image security database variable, but variable name is not in the lists.\r
-\r
-**/\r
-EFI_STATUS\r
-GetUefiDefinedVariableProperty (\r
-  IN CHAR16                         *VariableName,\r
-  IN EFI_GUID                       *VendorGuid,\r
-  IN BOOLEAN                        WildcardMatch,\r
-  OUT VAR_CHECK_VARIABLE_PROPERTY   **VariableProperty,\r
-  OUT INTERNAL_VAR_CHECK_FUNCTION   *VarCheckFunction OPTIONAL\r
-  )\r
-{\r
-  UINTN     Index;\r
-  UINTN     NameLength;\r
-\r
-  if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid)) {\r
-    //\r
-    // Try list 1, exactly match.\r
-    //\r
-    for (Index = 0; Index < sizeof (mGlobalVariableList)/sizeof (mGlobalVariableList[0]); Index++) {\r
-      if (StrCmp (mGlobalVariableList[Index].Name, VariableName) == 0) {\r
-        if (VarCheckFunction != NULL) {\r
-          *VarCheckFunction = mGlobalVariableList[Index].CheckFunction;\r
-        }\r
-        *VariableProperty = &mGlobalVariableList[Index].VariableProperty;\r
-        return EFI_SUCCESS;\r
-      }\r
-    }\r
-\r
-    //\r
-    // Try list 2.\r
-    //\r
-    NameLength = StrLen (VariableName) - 4;\r
-    for (Index = 0; Index < sizeof (mGlobalVariableList2)/sizeof (mGlobalVariableList2[0]); Index++) {\r
-      if (WildcardMatch) {\r
-        if ((StrLen (VariableName) == StrLen (mGlobalVariableList2[Index].Name)) &&\r
-            (StrnCmp (mGlobalVariableList2[Index].Name, VariableName, NameLength) == 0) &&\r
-            IsHexaDecimalDigitCharacter (VariableName[NameLength]) &&\r
-            IsHexaDecimalDigitCharacter (VariableName[NameLength + 1]) &&\r
-            IsHexaDecimalDigitCharacter (VariableName[NameLength + 2]) &&\r
-            IsHexaDecimalDigitCharacter (VariableName[NameLength + 3])) {\r
-          if (VarCheckFunction != NULL) {\r
-            *VarCheckFunction = mGlobalVariableList2[Index].CheckFunction;\r
-          }\r
-          *VariableProperty = &mGlobalVariableList2[Index].VariableProperty;\r
-          return EFI_SUCCESS;\r
-        }\r
-      }\r
-      if (StrCmp (mGlobalVariableList2[Index].Name, VariableName) == 0) {\r
-        if (VarCheckFunction != NULL) {\r
-          *VarCheckFunction = mGlobalVariableList2[Index].CheckFunction;\r
-        }\r
-        *VariableProperty = &mGlobalVariableList2[Index].VariableProperty;\r
-        return EFI_SUCCESS;\r
-      }\r
-    }\r
-\r
-    //\r
-    // The variable name is not in the lists.\r
-    //\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  if (CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid)){\r
-    for (Index = 0; Index < sizeof (mImageSecurityVariableList)/sizeof (mImageSecurityVariableList[0]); Index++) {\r
-      if (StrCmp (mImageSecurityVariableList[Index].Name, VariableName) == 0) {\r
-        if (VarCheckFunction != NULL) {\r
-          *VarCheckFunction = mImageSecurityVariableList[Index].CheckFunction;\r
-        }\r
-        *VariableProperty = &mImageSecurityVariableList[Index].VariableProperty;\r
-        return EFI_SUCCESS;\r
-      }\r
-    }\r
-\r
-    return EFI_INVALID_PARAMETER;\r
-  }\r
-\r
-  //\r
-  // It is not global variable or image security database variable.\r
-  //\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Get variable property for variables managed by Varaible driver.\r
-\r
-  @param[in]  VariableName      Pointer to variable name.\r
-  @param[in]  VendorGuid        Variable Vendor Guid.\r
-\r
-  @return Pointer to variable property.\r
-\r
-**/\r
-VAR_CHECK_VARIABLE_PROPERTY *\r
-GetVariableDriverVariableProperty (\r
-  IN CHAR16                         *VariableName,\r
-  IN EFI_GUID                       *VendorGuid\r
-  )\r
-{\r
-  UINTN     Index;\r
-\r
-  for (Index = 0; Index < sizeof (mVariableDriverVariableList)/sizeof (mVariableDriverVariableList[0]); Index++) {\r
-    if ((CompareGuid (mVariableDriverVariableList[Index].Guid, VendorGuid)) && (StrCmp (mVariableDriverVariableList[Index].Name, VariableName) == 0)) {\r
-      return &mVariableDriverVariableList[Index].VariableProperty;\r
-    }\r
-  }\r
-\r
-  return NULL;\r
-}\r
-\r
-/**\r
-  Internal SetVariable check.\r
-\r
-  @param[in] VariableName       Name of Variable to set.\r
-  @param[in] VendorGuid         Variable vendor GUID.\r
-  @param[in] Attributes         Attribute value of the variable.\r
-  @param[in] DataSize           Size of Data to set.\r
-  @param[in] Data               Data pointer.\r
-\r
-  @retval EFI_SUCCESS           The SetVariable check result was success.\r
-  @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits, name, and GUID was supplied,\r
-                                or the DataSize exceeds the minimum or maximum allowed,\r
-                                or the Data value is not following UEFI spec for UEFI defined variables.\r
-  @retval EFI_WRITE_PROTECTED   The variable in question is read-only.\r
-  @retval Others                The return status from check handler.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-InternalVarCheckSetVariableCheck (\r
-  IN CHAR16     *VariableName,\r
-  IN EFI_GUID   *VendorGuid,\r
-  IN UINT32     Attributes,\r
-  IN UINTN      DataSize,\r
-  IN VOID       *Data\r
-  )\r
-{\r
-  EFI_STATUS                    Status;\r
-  UINTN                         Index;\r
-  LIST_ENTRY                    *Link;\r
-  VAR_CHECK_VARIABLE_ENTRY      *Entry;\r
-  CHAR16                        *Name;\r
-  VAR_CHECK_VARIABLE_PROPERTY   *Property;\r
-  INTERNAL_VAR_CHECK_FUNCTION   VarCheckFunction;\r
-\r
-  if (!mEndOfDxe) {\r
-    //\r
-    // Only do check after End Of Dxe.\r
-    //\r
-    return EFI_SUCCESS;\r
-  }\r
-\r
-  Property = NULL;\r
-  VarCheckFunction = NULL;\r
-\r
-  for ( Link = GetFirstNode (&mVarCheckVariableList)\r
-      ; !IsNull (&mVarCheckVariableList, Link)\r
-      ; Link = GetNextNode (&mVarCheckVariableList, Link)\r
-      ) {\r
-    Entry = BASE_CR (Link, VAR_CHECK_VARIABLE_ENTRY, Link);\r
-    Name = (CHAR16 *) ((UINTN) Entry + sizeof (*Entry));\r
-    if (CompareGuid (&Entry->Guid, VendorGuid) && (StrCmp (Name, VariableName) == 0)) {\r
-      Property = &Entry->VariableProperty;\r
-      break;\r
-    }\r
-  }\r
-  if (Property == NULL) {\r
-    Property = GetVariableDriverVariableProperty (VariableName, VendorGuid);\r
-  }\r
-  if (Property == NULL) {\r
-    Status = GetUefiDefinedVariableProperty (VariableName, VendorGuid, TRUE, &Property, &VarCheckFunction);\r
-    if (EFI_ERROR (Status)) {\r
-      DEBUG ((EFI_D_INFO, "[Variable]: Var Check UEFI defined variable fail %r - %g:%s\n", Status, VendorGuid, VariableName));\r
-      return Status;\r
-    }\r
-  }\r
-  if (Property != NULL) {\r
-    if (mEnableLocking && ((Property->Property & VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY) != 0)) {\r
-      DEBUG ((EFI_D_INFO, "[Variable]: Var Check ReadOnly variable fail %r - %g:%s\n", EFI_WRITE_PROTECTED, VendorGuid, VariableName));\r
-      return EFI_WRITE_PROTECTED;\r
-    }\r
-    if (!((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0))) {\r
-      //\r
-      // Not to delete variable.\r
-      //\r
-      if ((Attributes & (~EFI_VARIABLE_APPEND_WRITE)) != Property->Attributes) {\r
-        DEBUG ((EFI_D_INFO, "[Variable]: Var Check Attributes(0x%08x to 0x%08x) fail %r - %g:%s\n", Property->Attributes, Attributes, EFI_INVALID_PARAMETER, VendorGuid, VariableName));\r
-        return EFI_INVALID_PARAMETER;\r
-      }\r
-      if (DataSize != 0) {\r
-        if ((DataSize < Property->MinSize) || (DataSize > Property->MaxSize)) {\r
-          DEBUG ((EFI_D_INFO, "[Variable]: Var Check DataSize fail(0x%x not in 0x%x - 0x%x) %r - %g:%s\n", DataSize, Property->MinSize, Property->MaxSize, EFI_INVALID_PARAMETER, VendorGuid, VariableName));\r
-          return EFI_INVALID_PARAMETER;\r
-        }\r
-        if (VarCheckFunction != NULL) {\r
-          Status = VarCheckFunction (\r
-                     Property,\r
-                     DataSize,\r
-                     Data\r
-                     );\r
-          if (EFI_ERROR (Status)) {\r
-            DEBUG ((EFI_D_INFO, "[Variable]: Internal Var Check function fail %r - %g:%s\n", Status, VendorGuid, VariableName));\r
-            return Status;\r
-          }\r
-        }\r
-      }\r
-    }\r
-  }\r
-\r
-  for (Index = 0; Index < mNumberOfHandler; Index ++) {\r
-    Status = mHandlerTable[Index] (\r
-               VariableName,\r
-               VendorGuid,\r
-               Attributes,\r
-               DataSize,\r
-               Data\r
-               );\r
-    if (EFI_ERROR (Status)) {\r
-      DEBUG ((EFI_D_INFO, "[Variable]: Var Check handler fail %r - %g:%s\n", Status, VendorGuid, VariableName));\r
-      return Status;\r
-    }\r
-  }\r
-  return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
-  Reallocates more global memory to store the registered handler list.\r
-\r
-  @retval RETURN_SUCCESS            Reallocate memory successfully.\r
-  @retval RETURN_OUT_OF_RESOURCES   No enough memory to allocate.\r
-\r
-**/\r
-RETURN_STATUS\r
-EFIAPI\r
-ReallocateHandlerTable (\r
-  VOID\r
-  )\r
-{\r
-  VAR_CHECK_SET_VARIABLE_CHECK_HANDLER  *HandlerTable;\r
-\r
-  //\r
-  // Reallocate memory for check handler table.\r
-  //\r
-  HandlerTable = ReallocateRuntimePool (\r
-                     mMaxNumberOfHandler * sizeof (VAR_CHECK_SET_VARIABLE_CHECK_HANDLER), \r
-                     (mMaxNumberOfHandler + VAR_CHECK_HANDLER_TABLE_SIZE) * sizeof (VAR_CHECK_SET_VARIABLE_CHECK_HANDLER), \r
-                     mHandlerTable\r
-                     );\r
-\r
-  //\r
-  // No enough resource to allocate.\r
-  //\r
-  if (HandlerTable == NULL) {\r
-    return RETURN_OUT_OF_RESOURCES;\r
-  }\r
-\r
-  mHandlerTable = HandlerTable;\r
-  //\r
-  // Increase max handler number.\r
-  //\r
-  mMaxNumberOfHandler = mMaxNumberOfHandler + VAR_CHECK_HANDLER_TABLE_SIZE;\r
-  return RETURN_SUCCESS;\r
-}\r
-\r
-/**\r
-  Register SetVariable check handler.\r
-\r
-  @param[in] Handler            Pointer to check handler.\r
-\r
-  @retval EFI_SUCCESS           The SetVariable check handler was registered successfully.\r
-  @retval EFI_INVALID_PARAMETER Handler is NULL.\r
-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has\r
-                                already been signaled.\r