MdeModulePkg/Library/VarCheckUefiLib/VarCheckUefiLibNullClass.c

   1 /** @file
   2   Implementation functions and structures for var check uefi library.
   3
   4 Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <Uefi/UefiBaseType.h>
  16
  17 #include <Library/VarCheckLib.h>
  18 #include <Library/BaseLib.h>
  19 #include <Library/BaseMemoryLib.h>
  20 #include <Library/DebugLib.h>
  21 #include <Library/DevicePathLib.h>
  22
  23 #include <Guid/VariableFormat.h>
  24 #include <Guid/GlobalVariable.h>
  25 #include <Guid/HardwareErrorVariable.h>
  26 #include <Guid/ImageAuthentication.h>
  27
  28 typedef
  29 EFI_STATUS
  30 (EFIAPI *INTERNAL_VAR_CHECK_FUNCTION) (
  31   IN VAR_CHECK_VARIABLE_PROPERTY    *Propery,
  32   IN UINTN                          DataSize,
  33   IN VOID                           *Data
  34   );
  35
  36 typedef struct {
  37   CHAR16                        *Name;
  38   VAR_CHECK_VARIABLE_PROPERTY   VariableProperty;
  39   INTERNAL_VAR_CHECK_FUNCTION   CheckFunction;
  40 } UEFI_DEFINED_VARIABLE_ENTRY;
  41
  42 /**
  43   Internal check for load option.
  44
  45   @param[in] VariablePropery    Pointer to variable property.
  46   @param[in] DataSize           Data size.
  47   @param[in] Data               Pointer to data buffer.
  48
  49   @retval EFI_SUCCESS           The SetVariable check result was success.
  50   @retval EFI_INVALID_PARAMETER The data buffer is not a valid load option.
  51
  52 **/
  53 EFI_STATUS
  54 EFIAPI
  55 InternalVarCheckLoadOption (
  56   IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,
  57   IN UINTN                          DataSize,
  58   IN VOID                           *Data
  59   )
  60 {
  61   UINT16                    FilePathListLength;
  62   CHAR16                    *Description;
  63   EFI_DEVICE_PATH_PROTOCOL  *FilePathList;
  64
  65   FilePathListLength = *((UINT16 *) ((UINTN) Data + sizeof (UINT32)));
  66
  67   //
  68   // Check Description
  69   //
  70   Description = (CHAR16 *) ((UINTN) Data + sizeof (UINT32) + sizeof (UINT16));
  71   while (Description < (CHAR16 *) ((UINTN) Data + DataSize)) {
  72     if (*Description == L'\0') {
  73       break;
  74     }
  75     Description++;
  76   }
  77   if ((UINTN) Description >= ((UINTN) Data + DataSize)) {
  78     return EFI_INVALID_PARAMETER;
  79   }
  80   Description++;
  81
  82   //
  83   // Check FilePathList
  84   //
  85   FilePathList = (EFI_DEVICE_PATH_PROTOCOL *) Description;
  86   if ((UINTN) FilePathList > (MAX_ADDRESS - FilePathListLength)) {
  87     return EFI_INVALID_PARAMETER;
  88   }
  89   if (((UINTN) FilePathList + FilePathListLength) > ((UINTN) Data + DataSize)) {
  90     return EFI_INVALID_PARAMETER;
  91   }
  92   if (FilePathListLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
  93     return EFI_INVALID_PARAMETER;
  94   }
  95   if (!IsDevicePathValid (FilePathList, FilePathListLength)) {
  96     return EFI_INVALID_PARAMETER;
  97   }
  98
  99   return EFI_SUCCESS;
 100 }
 101
 102 /**
 103   Internal check for key option.
 104
 105   @param[in] VariablePropery    Pointer to variable property.
 106   @param[in] DataSize           Data size.
 107   @param[in] Data               Pointer to data buffer.
 108
 109   @retval EFI_SUCCESS           The SetVariable check result was success.
 110   @retval EFI_INVALID_PARAMETER The data buffer is not a valid key option.
 111
 112 **/
 113 EFI_STATUS
 114 EFIAPI
 115 InternalVarCheckKeyOption (
 116   IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,
 117   IN UINTN                          DataSize,
 118   IN VOID                           *Data
 119   )
 120 {
 121   if (((DataSize - sizeof (EFI_KEY_OPTION)) % sizeof (EFI_INPUT_KEY)) != 0) {
 122     return EFI_INVALID_PARAMETER;
 123   }
 124
 125   return EFI_SUCCESS;
 126 }
 127
 128 /**
 129   Internal check for device path.
 130
 131   @param[in] VariablePropery    Pointer to variable property.
 132   @param[in] DataSize           Data size.
 133   @param[in] Data               Pointer to data buffer.
 134
 135   @retval EFI_SUCCESS           The SetVariable check result was success.
 136   @retval EFI_INVALID_PARAMETER The data buffer is not a valid device path.
 137
 138 **/
 139 EFI_STATUS
 140 EFIAPI
 141 InternalVarCheckDevicePath (
 142   IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,
 143   IN UINTN                          DataSize,
 144   IN VOID                           *Data
 145   )
 146 {
 147   if (!IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL *) Data, DataSize)) {
 148     return EFI_INVALID_PARAMETER;
 149   }
 150   return EFI_SUCCESS;
 151 }
 152
 153 /**
 154   Internal check for ASCII string.
 155
 156   @param[in] VariablePropery    Pointer to variable property.
 157   @param[in] DataSize           Data size.
 158   @param[in] Data               Pointer to data buffer.
 159
 160   @retval EFI_SUCCESS           The SetVariable check result was success.
 161   @retval EFI_INVALID_PARAMETER The data buffer is not a Null-terminated ASCII string.
 162
 163 **/
 164 EFI_STATUS
 165 EFIAPI
 166 InternalVarCheckAsciiString (
 167   IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,
 168   IN UINTN                          DataSize,
 169   IN VOID                           *Data
 170   )
 171 {
 172   CHAR8     *String;
 173   UINTN     Index;
 174
 175   String = (CHAR8 *) Data;
 176   if (String[DataSize - 1] == '\0') {
 177     return EFI_SUCCESS;
 178   } else {
 179     for (Index = 1; Index < DataSize && (String[DataSize - 1 - Index] != '\0'); Index++);
 180     if (Index == DataSize) {
 181       return EFI_INVALID_PARAMETER;
 182     }
 183   }
 184   return EFI_SUCCESS;
 185 }
 186
 187 /**
 188   Internal check for size array.
 189
 190   @param[in] VariablePropery    Pointer to variable property.
 191   @param[in] DataSize           Data size.
 192   @param[in] Data               Pointer to data buffer.
 193
 194   @retval EFI_SUCCESS           The SetVariable check result was success.
 195   @retval EFI_INVALID_PARAMETER The DataSize is not size array.
 196
 197 **/
 198 EFI_STATUS
 199 EFIAPI
 200 InternalVarCheckSizeArray (
 201   IN VAR_CHECK_VARIABLE_PROPERTY    *VariablePropery,
 202   IN UINTN                          DataSize,
 203   IN VOID                           *Data
 204   )
 205 {
 206   if ((DataSize % VariablePropery->MinSize) != 0) {
 207     return EFI_INVALID_PARAMETER;
 208   }
 209   return EFI_SUCCESS;
 210 }
 211
 212 //
 213 // To prevent name collisions with possible future globally defined variables,
 214 // other internal firmware data variables that are not defined here must be
 215 // saved with a unique VendorGuid other than EFI_GLOBAL_VARIABLE or
 216 // any other GUID defined by the UEFI Specification. Implementations must
 217 // only permit the creation of variables with a UEFI Specification-defined
 218 // VendorGuid when these variables are documented in the UEFI Specification.
 219 //
 220 UEFI_DEFINED_VARIABLE_ENTRY mGlobalVariableList[] = {
 221   {
 222     EFI_LANG_CODES_VARIABLE_NAME,
 223     {
 224       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 225       0,
 226       VARIABLE_ATTRIBUTE_BS_RT,
 227       1,
 228       MAX_UINTN
 229     },
 230     InternalVarCheckAsciiString
 231   },
 232   {
 233     EFI_LANG_VARIABLE_NAME,
 234     {
 235       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 236       0,
 237       VARIABLE_ATTRIBUTE_NV_BS_RT,
 238       1,
 239       MAX_UINTN
 240     },
 241     InternalVarCheckAsciiString
 242   },
 243   {
 244     EFI_TIME_OUT_VARIABLE_NAME,
 245     {
 246       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 247       0,
 248       VARIABLE_ATTRIBUTE_NV_BS_RT,
 249       sizeof (UINT16),
 250       sizeof (UINT16)
 251     },
 252     NULL
 253   },
 254   {
 255     EFI_PLATFORM_LANG_CODES_VARIABLE_NAME,
 256     {
 257       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 258       0,
 259       VARIABLE_ATTRIBUTE_BS_RT,
 260       1,
 261       MAX_UINTN
 262     },
 263     InternalVarCheckAsciiString
 264   },
 265   {
 266     EFI_PLATFORM_LANG_VARIABLE_NAME,
 267     {
 268       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 269       0,
 270       VARIABLE_ATTRIBUTE_NV_BS_RT,
 271       1,
 272       MAX_UINTN
 273     },
 274     InternalVarCheckAsciiString
 275   },
 276   {
 277     EFI_CON_IN_VARIABLE_NAME,
 278     {
 279       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 280       0,
 281       VARIABLE_ATTRIBUTE_NV_BS_RT,
 282       sizeof (EFI_DEVICE_PATH_PROTOCOL),
 283       MAX_UINTN
 284     },
 285     InternalVarCheckDevicePath
 286   },
 287   {
 288     EFI_CON_OUT_VARIABLE_NAME,
 289     {
 290       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 291       0,
 292       VARIABLE_ATTRIBUTE_NV_BS_RT,
 293       sizeof (EFI_DEVICE_PATH_PROTOCOL),
 294       MAX_UINTN
 295     },
 296     InternalVarCheckDevicePath
 297   },
 298   {
 299     EFI_ERR_OUT_VARIABLE_NAME,
 300     {
 301       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 302       0,
 303       VARIABLE_ATTRIBUTE_NV_BS_RT,
 304       sizeof (EFI_DEVICE_PATH_PROTOCOL),
 305       MAX_UINTN
 306     },
 307     InternalVarCheckDevicePath
 308   },
 309   {
 310     EFI_CON_IN_DEV_VARIABLE_NAME,
 311     {
 312       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 313       0,
 314       VARIABLE_ATTRIBUTE_BS_RT,
 315       sizeof (EFI_DEVICE_PATH_PROTOCOL),
 316       MAX_UINTN
 317     },
 318     InternalVarCheckDevicePath
 319   },
 320   {
 321     EFI_CON_OUT_DEV_VARIABLE_NAME,
 322     {
 323       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 324       0,
 325       VARIABLE_ATTRIBUTE_BS_RT,
 326       sizeof (EFI_DEVICE_PATH_PROTOCOL),
 327       MAX_UINTN
 328     },
 329     InternalVarCheckDevicePath
 330   },
 331   {
 332     EFI_ERR_OUT_DEV_VARIABLE_NAME,
 333     {
 334       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 335       0,
 336       VARIABLE_ATTRIBUTE_BS_RT,
 337       sizeof (EFI_DEVICE_PATH_PROTOCOL),
 338       MAX_UINTN
 339     },
 340     InternalVarCheckDevicePath
 341   },
 342   {
 343     EFI_BOOT_ORDER_VARIABLE_NAME,
 344     {
 345       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 346       0,
 347       VARIABLE_ATTRIBUTE_NV_BS_RT,
 348       sizeof (UINT16),
 349       MAX_UINTN
 350     },
 351     InternalVarCheckSizeArray
 352   },
 353   {
 354     EFI_BOOT_NEXT_VARIABLE_NAME,
 355     {
 356       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 357       0,
 358       VARIABLE_ATTRIBUTE_NV_BS_RT,
 359       sizeof (UINT16),
 360       sizeof (UINT16)
 361     },
 362     NULL
 363   },
 364   {
 365     EFI_BOOT_CURRENT_VARIABLE_NAME,
 366     {
 367       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 368       0,
 369       VARIABLE_ATTRIBUTE_BS_RT,
 370       sizeof (UINT16),
 371       sizeof (UINT16)
 372     },
 373     NULL
 374   },
 375   {
 376     EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME,
 377     {
 378       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 379       0,
 380       VARIABLE_ATTRIBUTE_BS_RT,
 381       sizeof (UINT32),
 382       sizeof (UINT32)
 383     },
 384     NULL
 385   },
 386   {
 387     EFI_DRIVER_ORDER_VARIABLE_NAME,
 388     {
 389       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 390       0,
 391       VARIABLE_ATTRIBUTE_NV_BS_RT,
 392       sizeof (UINT16),
 393       MAX_UINTN
 394     },
 395     InternalVarCheckSizeArray
 396   },
 397   {
 398     EFI_SYS_PREP_ORDER_VARIABLE_NAME,
 399     {
 400       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 401       0,
 402       VARIABLE_ATTRIBUTE_NV_BS_RT,
 403       sizeof (UINT16),
 404       MAX_UINTN
 405     },
 406     InternalVarCheckSizeArray
 407   },
 408   {
 409     EFI_HW_ERR_REC_SUPPORT_VARIABLE_NAME,
 410     {
 411       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 412       0,
 413       VARIABLE_ATTRIBUTE_NV_BS_RT,
 414       sizeof (UINT16),
 415       sizeof (UINT16)
 416     },
 417     NULL
 418   },
 419   {
 420     EFI_SETUP_MODE_NAME,
 421     {
 422       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 423       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 424       VARIABLE_ATTRIBUTE_BS_RT,
 425       sizeof (UINT8),
 426       sizeof (UINT8)
 427     },
 428     NULL
 429   },
 430   {
 431     EFI_KEY_EXCHANGE_KEY_NAME,
 432     {
 433       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 434       0,
 435       VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
 436       1,
 437       MAX_UINTN
 438     },
 439     NULL
 440   },
 441   {
 442     EFI_PLATFORM_KEY_NAME,
 443     {
 444       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 445       0,
 446       VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
 447       1,
 448       MAX_UINTN
 449     },
 450     NULL
 451   },
 452   {
 453     EFI_SIGNATURE_SUPPORT_NAME,
 454     {
 455       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 456       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 457       VARIABLE_ATTRIBUTE_BS_RT,
 458       sizeof (EFI_GUID),
 459       MAX_UINTN
 460     },
 461     InternalVarCheckSizeArray
 462   },
 463   {
 464     EFI_SECURE_BOOT_MODE_NAME,
 465     {
 466       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 467       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 468       VARIABLE_ATTRIBUTE_BS_RT,
 469       sizeof (UINT8),
 470       sizeof (UINT8)
 471     },
 472     NULL
 473   },
 474   {
 475     EFI_KEK_DEFAULT_VARIABLE_NAME,
 476     {
 477       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 478       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 479       VARIABLE_ATTRIBUTE_BS_RT,
 480       1,
 481       MAX_UINTN
 482     },
 483     NULL
 484   },
 485   {
 486     EFI_PK_DEFAULT_VARIABLE_NAME,
 487     {
 488       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 489       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 490       VARIABLE_ATTRIBUTE_BS_RT,
 491       1,
 492       MAX_UINTN
 493     },
 494     NULL
 495   },
 496   {
 497     EFI_DB_DEFAULT_VARIABLE_NAME,
 498     {
 499       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 500       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 501       VARIABLE_ATTRIBUTE_BS_RT,
 502       1,
 503       MAX_UINTN
 504     },
 505     NULL
 506   },
 507   {
 508     EFI_DBX_DEFAULT_VARIABLE_NAME,
 509     {
 510       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 511       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 512       VARIABLE_ATTRIBUTE_BS_RT,
 513       1,
 514       MAX_UINTN
 515     },
 516     NULL
 517   },
 518   {
 519     EFI_DBT_DEFAULT_VARIABLE_NAME,
 520     {
 521       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 522       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 523       VARIABLE_ATTRIBUTE_BS_RT,
 524       1,
 525       MAX_UINTN
 526     },
 527     NULL
 528   },
 529   {
 530     EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME,
 531     {
 532       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 533       0,
 534       VARIABLE_ATTRIBUTE_BS_RT,
 535       sizeof (UINT64),
 536       sizeof (UINT64)
 537     },
 538     NULL
 539   },
 540   {
 541     EFI_OS_INDICATIONS_VARIABLE_NAME,
 542     {
 543       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 544       0,
 545       VARIABLE_ATTRIBUTE_NV_BS_RT,
 546       sizeof (UINT64),
 547       sizeof (UINT64)
 548     },
 549     NULL
 550   },
 551   {
 552     EFI_VENDOR_KEYS_VARIABLE_NAME,
 553     {
 554       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 555       VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
 556       VARIABLE_ATTRIBUTE_BS_RT,
 557       sizeof (UINT8),
 558       sizeof (UINT8)
 559     },
 560     NULL
 561   },
 562 };
 563
 564 UEFI_DEFINED_VARIABLE_ENTRY mGlobalVariableList2[] = {
 565   {
 566     L"Boot####",
 567     {
 568       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 569       0,
 570       VARIABLE_ATTRIBUTE_NV_BS_RT,
 571       sizeof (UINT32) + sizeof (UINT16),
 572       MAX_UINTN
 573     },
 574     InternalVarCheckLoadOption
 575   },
 576   {
 577     L"Driver####",
 578     {
 579       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 580       0,
 581       VARIABLE_ATTRIBUTE_NV_BS_RT,
 582       sizeof (UINT32) + sizeof (UINT16),
 583       MAX_UINTN
 584     },
 585     InternalVarCheckLoadOption
 586   },
 587   {
 588     L"SysPrep####",
 589     {
 590       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 591       0,
 592       VARIABLE_ATTRIBUTE_NV_BS_RT,
 593       sizeof (UINT32) + sizeof (UINT16),
 594       MAX_UINTN
 595     },
 596     InternalVarCheckLoadOption
 597   },
 598   {
 599     L"Key####",
 600     {
 601       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 602       0,
 603       VARIABLE_ATTRIBUTE_NV_BS_RT,
 604       sizeof (EFI_KEY_OPTION),
 605       sizeof (EFI_KEY_OPTION) + 3 * sizeof (EFI_INPUT_KEY)
 606     },
 607     InternalVarCheckKeyOption
 608   },
 609   {
 610     L"PlatformRecovery####",
 611     {
 612       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 613       0,
 614       VARIABLE_ATTRIBUTE_BS_RT,
 615       sizeof (UINT32) + sizeof (UINT16),
 616       MAX_UINTN
 617     },
 618     InternalVarCheckLoadOption
 619   },
 620 };
 621
 622 //
 623 // EFI_IMAGE_SECURITY_DATABASE_GUID
 624 //
 625 UEFI_DEFINED_VARIABLE_ENTRY mImageSecurityVariableList[] = {
 626   {
 627     EFI_IMAGE_SECURITY_DATABASE,
 628     {
 629       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 630       0,
 631       VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
 632       1,
 633       MAX_UINTN
 634     },
 635     NULL
 636   },
 637   {
 638     EFI_IMAGE_SECURITY_DATABASE1,
 639     {
 640       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 641       0,
 642       VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
 643       1,
 644       MAX_UINTN
 645     },
 646     NULL
 647   },
 648   {
 649     EFI_IMAGE_SECURITY_DATABASE2,
 650     {
 651       VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 652       0,
 653       VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
 654       1,
 655       MAX_UINTN
 656     },
 657     NULL
 658   },
 659 };
 660
 661 //
 662 // EFI_HARDWARE_ERROR_VARIABLE
 663 //
 664 UEFI_DEFINED_VARIABLE_ENTRY mHwErrRecVariable = {
 665   L"HwErrRec####",
 666   {
 667     VAR_CHECK_VARIABLE_PROPERTY_REVISION,
 668     0,
 669     VARIABLE_ATTRIBUTE_NV_BS_RT_HR,
 670     1,
 671     MAX_UINTN
 672   },
 673   NULL
 674 };
 675
 676 EFI_GUID *mUefiDefinedGuid[] = {
 677   &gEfiGlobalVariableGuid,
 678   &gEfiImageSecurityDatabaseGuid,
 679   &gEfiHardwareErrorVariableGuid
 680 };
 681
 682 /**
 683   Check if a Unicode character is an upper case hexadecimal character.
 684
 685   This function checks if a Unicode character is an upper case
 686   hexadecimal character.  The valid upper case hexadecimal character is
 687   L'0' to L'9', or L'A' to L'F'.
 688
 689
 690   @param[in] Char       The character to check against.
 691
 692   @retval TRUE          If the Char is an upper case hexadecmial character.
 693   @retval FALSE         If the Char is not an upper case hexadecmial character.
 694
 695 **/
 696 BOOLEAN
 697 EFIAPI
 698 VarCheckUefiIsHexaDecimalDigitCharacter (
 699   IN CHAR16             Char
 700   )
 701 {
 702   return (BOOLEAN) ((Char >= L'0' && Char <= L'9') || (Char >= L'A' && Char <= L'F'));
 703 }
 704
 705 /**
 706
 707   This code checks if variable is hardware error record variable or not.
 708
 709   According to UEFI spec, hardware error record variable should use the EFI_HARDWARE_ERROR_VARIABLE VendorGuid
 710   and have the L"HwErrRec####" name convention, #### is a printed hex value and no 0x or h is included in the hex value.
 711
 712   @param[in] VariableName   Pointer to variable name.
 713   @param[in] VendorGuid     Variable Vendor Guid.
 714
 715   @retval TRUE              Variable is hardware error record variable.
 716   @retval FALSE             Variable is not hardware error record variable.
 717
 718 **/
 719 BOOLEAN
 720 EFIAPI
 721 IsHwErrRecVariable (
 722   IN CHAR16             *VariableName,
 723   IN EFI_GUID           *VendorGuid
 724   )
 725 {
 726   if (!CompareGuid (VendorGuid, &gEfiHardwareErrorVariableGuid) ||
 727       (StrLen (VariableName) != StrLen (L"HwErrRec####")) ||
 728       (StrnCmp(VariableName, L"HwErrRec", StrLen (L"HwErrRec")) != 0) ||
 729       !VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[0x8]) ||
 730       !VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[0x9]) ||
 731       !VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[0xA]) ||
 732       !VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[0xB])) {
 733     return FALSE;
 734   }
 735
 736   return TRUE;
 737 }
 738
 739 /**
 740   Get UEFI defined var check function.
 741
 742   @param[in]  VariableName      Pointer to variable name.
 743   @param[in]  VendorGuid        Pointer to variable vendor GUID.
 744   @param[out] VariableProperty  Pointer to variable property.
 745
 746   @return Internal var check function, NULL if no specific check function.
 747
 748 **/
 749 INTERNAL_VAR_CHECK_FUNCTION
 750 GetUefiDefinedVarCheckFunction (
 751   IN CHAR16                         *VariableName,
 752   IN EFI_GUID                       *VendorGuid,
 753   OUT VAR_CHECK_VARIABLE_PROPERTY   **VariableProperty
 754   )
 755 {
 756   UINTN     Index;
 757   UINTN     NameLength;
 758
 759   if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid)) {
 760     //
 761     // Try list 1, exactly match.
 762     //
 763     for (Index = 0; Index < sizeof (mGlobalVariableList)/sizeof (mGlobalVariableList[0]); Index++) {
 764       if (StrCmp (mGlobalVariableList[Index].Name, VariableName) == 0) {
 765         *VariableProperty = &(mGlobalVariableList[Index].VariableProperty);
 766         return mGlobalVariableList[Index].CheckFunction;
 767       }
 768     }
 769
 770     //
 771     // Try list 2.
 772     //
 773     NameLength = StrLen (VariableName) - 4;
 774     for (Index = 0; Index < sizeof (mGlobalVariableList2)/sizeof (mGlobalVariableList2[0]); Index++) {
 775       if ((StrLen (VariableName) == StrLen (mGlobalVariableList2[Index].Name)) &&
 776           (StrnCmp (VariableName, mGlobalVariableList2[Index].Name, NameLength) == 0) &&
 777           VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[NameLength]) &&
 778           VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[NameLength + 1]) &&
 779           VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[NameLength + 2]) &&
 780           VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[NameLength + 3])) {
 781         *VariableProperty = &(mGlobalVariableList2[Index].VariableProperty);
 782         return mGlobalVariableList2[Index].CheckFunction;
 783       }
 784     }
 785   }
 786
 787   return NULL;
 788 }
 789
 790 /**
 791   SetVariable check handler UEFI defined.
 792
 793   @param[in] VariableName       Name of Variable to set.
 794   @param[in] VendorGuid         Variable vendor GUID.
 795   @param[in] Attributes         Attribute value of the variable.
 796   @param[in] DataSize           Size of Data to set.
 797   @param[in] Data               Data pointer.
 798
 799   @retval EFI_SUCCESS           The SetVariable check result was success.
 800   @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits, name, GUID,
 801                                 DataSize and Data value was supplied.
 802   @retval EFI_WRITE_PROTECTED   The variable in question is read-only.
 803
 804 **/
 805 EFI_STATUS
 806 EFIAPI
 807 SetVariableCheckHandlerUefiDefined (
 808   IN CHAR16     *VariableName,
 809   IN EFI_GUID   *VendorGuid,
 810   IN UINT32     Attributes,
 811   IN UINTN      DataSize,
 812   IN VOID       *Data
 813   )
 814 {
 815   EFI_STATUS                    Status;
 816   UINTN                         Index;
 817   VAR_CHECK_VARIABLE_PROPERTY   Property;
 818   VAR_CHECK_VARIABLE_PROPERTY   *VarCheckProperty;
 819   INTERNAL_VAR_CHECK_FUNCTION   VarCheckFunction;
 820
 821   if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0)) {
 822     //
 823     // Do not check delete variable.
 824     //
 825     return EFI_SUCCESS;
 826   }
 827
 828   if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
 829     if (!IsHwErrRecVariable (VariableName, VendorGuid)) {
 830       return EFI_INVALID_PARAMETER;
 831     }
 832   }
 833
 834   for (Index = 0; Index < sizeof (mUefiDefinedGuid)/sizeof (mUefiDefinedGuid[0]); Index++) {
 835     if (CompareGuid (VendorGuid, mUefiDefinedGuid[Index])) {
 836       if (VarCheckLibVariablePropertyGet (VariableName, VendorGuid, &Property) == EFI_NOT_FOUND) {
 837         //
 838         // To prevent name collisions with possible future globally defined variables,
 839         // other internal firmware data variables that are not defined here must be
 840         // saved with a unique VendorGuid other than EFI_GLOBAL_VARIABLE or
 841         // any other GUID defined by the UEFI Specification. Implementations must
 842         // only permit the creation of variables with a UEFI Specification-defined
 843         // VendorGuid when these variables are documented in the UEFI Specification.
 844         //
 845         DEBUG ((EFI_D_INFO, "UEFI Variable Check fail %r - %s not in %g namespace\n", EFI_INVALID_PARAMETER, VariableName, VendorGuid));
 846         return EFI_INVALID_PARAMETER;
 847       }
 848     }
 849   }
 850
 851   if (DataSize == 0) {
 852     return EFI_SUCCESS;
 853   }
 854
 855   VarCheckProperty = NULL;
 856   VarCheckFunction = GetUefiDefinedVarCheckFunction (VariableName, VendorGuid, &VarCheckProperty);
 857   if (VarCheckFunction != NULL) {
 858     Status = VarCheckFunction (
 859                VarCheckProperty,
 860                DataSize,
 861                Data
 862                );
 863     if (EFI_ERROR (Status)) {
 864       DEBUG ((EFI_D_INFO, "UEFI Variable Check function fail %r - %g:%s\n", Status, VendorGuid, VariableName));
 865       return Status;
 866     }
 867   }
 868
 869   return EFI_SUCCESS;
 870 }
 871
 872 /**
 873   Variable property set for UEFI defined variables.
 874
 875 **/
 876 VOID
 877 VariablePropertySetUefiDefined (
 878   VOID
 879   )
 880 {
 881   UINTN     Index;
 882
 883   //
 884   // EFI_GLOBAL_VARIABLE
 885   //
 886   for (Index = 0; Index < sizeof (mGlobalVariableList)/sizeof (mGlobalVariableList[0]); Index++) {
 887     VarCheckLibVariablePropertySet (
 888       mGlobalVariableList[Index].Name,
 889       &gEfiGlobalVariableGuid,
 890       &mGlobalVariableList[Index].VariableProperty
 891       );
 892   }
 893   for (Index = 0; Index < sizeof (mGlobalVariableList2)/sizeof (mGlobalVariableList2[0]); Index++) {
 894     VarCheckLibVariablePropertySet (
 895       mGlobalVariableList2[Index].Name,
 896       &gEfiGlobalVariableGuid,
 897       &mGlobalVariableList2[Index].VariableProperty
 898       );
 899   }
 900
 901   //
 902   // EFI_IMAGE_SECURITY_DATABASE_GUID
 903   //
 904   for (Index = 0; Index < sizeof (mImageSecurityVariableList)/sizeof (mImageSecurityVariableList[0]); Index++) {
 905     VarCheckLibVariablePropertySet (
 906       mImageSecurityVariableList[Index].Name,
 907       &gEfiImageSecurityDatabaseGuid,
 908       &mImageSecurityVariableList[Index].VariableProperty
 909       );
 910   }
 911
 912   //
 913   // EFI_HARDWARE_ERROR_VARIABLE
 914   //
 915   VarCheckLibVariablePropertySet (
 916     mHwErrRecVariable.Name,
 917     &gEfiHardwareErrorVariableGuid,
 918     &mHwErrRecVariable.VariableProperty
 919     );
 920 }
 921
 922 /**
 923   Constructor function of VarCheckUefiLib to set property and
 924   register SetVariable check handler for UEFI defined variables.
 925
 926   @retval EFI_SUCCESS       The constructor executed correctly.
 927
 928 **/
 929 RETURN_STATUS
 930 EFIAPI
 931 VarCheckUefiLibNullClassConstructor (
 932   VOID
 933   )
 934 {
 935   VariablePropertySetUefiDefined ();
 936   VarCheckLibRegisterSetVariableCheckHandler (SetVariableCheckHandlerUefiDefined);
 937
 938   return RETURN_SUCCESS;
 939 }