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