SecurityPkg/Library/DxeTcg2PhysicalPresenceLib/DxeTcg2PhysicalPresenceLib.c

   1 /** @file
   2   Execute pending TPM2 requests from OS or BIOS.
   3
   4   Caution: This module requires additional review when modified.
   5   This driver will have external input - variable.
   6   This external input must be validated carefully to avoid security issue.
   7
   8   Tpm2ExecutePendingTpmRequest() will receive untrusted input and do validation.
   9
  10 Copyright (c) 2013 - 2016, Intel Corporation. All rights reserved.<BR>
  11 This program and the accompanying materials
  12 are licensed and made available under the terms and conditions of the BSD License
  13 which accompanies this distribution.  The full text of the license may be found at
  14 http://opensource.org/licenses/bsd-license.php
  15
  16 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  17 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  18
  19 **/
  20
  21 #include <PiDxe.h>
  22
  23 #include <Protocol/Tcg2Protocol.h>
  24 #include <Protocol/VariableLock.h>
  25 #include <Library/DebugLib.h>
  26 #include <Library/BaseMemoryLib.h>
  27 #include <Library/UefiRuntimeServicesTableLib.h>
  28 #include <Library/UefiDriverEntryPoint.h>
  29 #include <Library/UefiBootServicesTableLib.h>
  30 #include <Library/UefiLib.h>
  31 #include <Library/MemoryAllocationLib.h>
  32 #include <Library/PrintLib.h>
  33 #include <Library/HiiLib.h>
  34 #include <Library/HobLib.h>
  35 #include <Guid/EventGroup.h>
  36 #include <Guid/Tcg2PhysicalPresenceData.h>
  37 #include <Library/Tpm2CommandLib.h>
  38 #include <Library/Tcg2PhysicalPresenceLib.h>
  39 #include <Library/Tcg2PpVendorLib.h>
  40
  41 #define CONFIRM_BUFFER_SIZE         4096
  42
  43 EFI_HII_HANDLE mTcg2PpStringPackHandle;
  44
  45 /**
  46   Get string by string id from HII Interface.
  47
  48   @param[in] Id          String ID.
  49
  50   @retval    CHAR16 *    String from ID.
  51   @retval    NULL        If error occurs.
  52
  53 **/
  54 CHAR16 *
  55 Tcg2PhysicalPresenceGetStringById (
  56   IN  EFI_STRING_ID   Id
  57   )
  58 {
  59   return HiiGetString (mTcg2PpStringPackHandle, Id, NULL);
  60 }
  61
  62 /**
  63   Send ClearControl and Clear command to TPM.
  64
  65   @param[in]  PlatformAuth      platform auth value. NULL means no platform auth change.
  66
  67   @retval EFI_SUCCESS           Operation completed successfully.
  68   @retval EFI_TIMEOUT           The register can't run into the expected status in time.
  69   @retval EFI_BUFFER_TOO_SMALL  Response data buffer is too small.
  70   @retval EFI_DEVICE_ERROR      Unexpected device behavior.
  71
  72 **/
  73 EFI_STATUS
  74 EFIAPI
  75 Tpm2CommandClear (
  76   IN TPM2B_AUTH                *PlatformAuth  OPTIONAL
  77   )
  78 {
  79   EFI_STATUS                Status;
  80   TPMS_AUTH_COMMAND         *AuthSession;
  81   TPMS_AUTH_COMMAND         LocalAuthSession;
  82
  83   if (PlatformAuth == NULL) {
  84     AuthSession = NULL;
  85   } else {
  86     AuthSession = &LocalAuthSession;
  87     ZeroMem (&LocalAuthSession, sizeof(LocalAuthSession));
  88     LocalAuthSession.sessionHandle = TPM_RS_PW;
  89     LocalAuthSession.hmac.size = PlatformAuth->size;
  90     CopyMem (LocalAuthSession.hmac.buffer, PlatformAuth->buffer, PlatformAuth->size);
  91   }
  92
  93   DEBUG ((EFI_D_INFO, "Tpm2ClearControl ... \n"));
  94   Status = Tpm2ClearControl (TPM_RH_PLATFORM, AuthSession, NO);
  95   DEBUG ((EFI_D_INFO, "Tpm2ClearControl - %r\n", Status));
  96   if (EFI_ERROR (Status)) {
  97     goto Done;
  98   }
  99   DEBUG ((EFI_D_INFO, "Tpm2Clear ... \n"));
 100   Status = Tpm2Clear (TPM_RH_PLATFORM, AuthSession);
 101   DEBUG ((EFI_D_INFO, "Tpm2Clear - %r\n", Status));
 102
 103 Done:
 104   ZeroMem (&LocalAuthSession.hmac, sizeof(LocalAuthSession.hmac));
 105   return Status;
 106 }
 107
 108 /**
 109   Change EPS.
 110
 111   @param[in]  PlatformAuth      platform auth value. NULL means no platform auth change.
 112
 113   @retval EFI_SUCCESS Operation completed successfully.
 114 **/
 115 EFI_STATUS
 116 Tpm2CommandChangeEps (
 117   IN TPM2B_AUTH                *PlatformAuth  OPTIONAL
 118   )
 119 {
 120   EFI_STATUS                Status;
 121   TPMS_AUTH_COMMAND         *AuthSession;
 122   TPMS_AUTH_COMMAND         LocalAuthSession;
 123
 124   if (PlatformAuth == NULL) {
 125     AuthSession = NULL;
 126   } else {
 127     AuthSession = &LocalAuthSession;
 128     ZeroMem (&LocalAuthSession, sizeof(LocalAuthSession));
 129     LocalAuthSession.sessionHandle = TPM_RS_PW;
 130     LocalAuthSession.hmac.size = PlatformAuth->size;
 131     CopyMem (LocalAuthSession.hmac.buffer, PlatformAuth->buffer, PlatformAuth->size);
 132   }
 133
 134   Status = Tpm2ChangeEPS (TPM_RH_PLATFORM, AuthSession);
 135   DEBUG ((EFI_D_INFO, "Tpm2ChangeEPS - %r\n", Status));
 136
 137   ZeroMem(&LocalAuthSession.hmac, sizeof(LocalAuthSession.hmac));
 138   return Status;
 139 }
 140
 141 /**
 142   Execute physical presence operation requested by the OS.
 143
 144   @param[in]      PlatformAuth        platform auth value. NULL means no platform auth change.
 145   @param[in]      CommandCode         Physical presence operation value.
 146   @param[in]      CommandParameter    Physical presence operation parameter.
 147   @param[in, out] PpiFlags            The physical presence interface flags.
 148
 149   @retval TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE   Unknown physical presence operation.
 150   @retval TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE   Error occurred during sending command to TPM or
 151                                                    receiving response from TPM.
 152   @retval Others                                   Return code from the TPM device after command execution.
 153 **/
 154 UINT32
 155 Tcg2ExecutePhysicalPresence (
 156   IN      TPM2B_AUTH                       *PlatformAuth,  OPTIONAL
 157   IN      UINT32                           CommandCode,
 158   IN      UINT32                           CommandParameter,
 159   IN OUT  EFI_TCG2_PHYSICAL_PRESENCE_FLAGS *PpiFlags
 160   )
 161 {
 162   EFI_STATUS                        Status;
 163   EFI_TCG2_EVENT_ALGORITHM_BITMAP   TpmHashAlgorithmBitmap;
 164   UINT32                            ActivePcrBanks;
 165
 166   switch (CommandCode) {
 167     case TCG2_PHYSICAL_PRESENCE_CLEAR:
 168     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR:
 169     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_2:
 170     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_3:
 171       Status = Tpm2CommandClear (PlatformAuth);
 172       if (EFI_ERROR (Status)) {
 173         return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
 174       } else {
 175         return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 176       }
 177
 178     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CLEAR_TRUE:
 179       PpiFlags->PPFlags |= TCG2_BIOS_TPM_MANAGEMENT_FLAG_PP_REQUIRED_FOR_CLEAR;
 180       return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 181
 182     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CLEAR_FALSE:
 183       PpiFlags->PPFlags &= ~TCG2_BIOS_TPM_MANAGEMENT_FLAG_PP_REQUIRED_FOR_CLEAR;
 184       return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 185
 186     case TCG2_PHYSICAL_PRESENCE_SET_PCR_BANKS:
 187       Status = Tpm2GetCapabilitySupportedAndActivePcrs (&TpmHashAlgorithmBitmap, &ActivePcrBanks);
 188       ASSERT_EFI_ERROR (Status);
 189       Status = Tpm2PcrAllocateBanks (PlatformAuth, TpmHashAlgorithmBitmap, CommandParameter);
 190       if (EFI_ERROR (Status)) {
 191         return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
 192       } else {
 193         return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 194       }
 195
 196     case TCG2_PHYSICAL_PRESENCE_CHANGE_EPS:
 197       Status = Tpm2CommandChangeEps (PlatformAuth);
 198       if (EFI_ERROR (Status)) {
 199         return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
 200       } else {
 201         return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 202       }
 203
 204     case TCG2_PHYSICAL_PRESENCE_LOG_ALL_DIGESTS:
 205       Status = Tpm2GetCapabilitySupportedAndActivePcrs (&TpmHashAlgorithmBitmap, &ActivePcrBanks);
 206       ASSERT_EFI_ERROR (Status);
 207       Status = Tpm2PcrAllocateBanks (PlatformAuth, TpmHashAlgorithmBitmap, TpmHashAlgorithmBitmap);
 208       if (EFI_ERROR (Status)) {
 209         return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
 210       } else {
 211         return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 212       }
 213
 214     case TCG2_PHYSICAL_PRESENCE_ENABLE_BLOCK_SID:
 215       PpiFlags->PPFlags |= TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_ENABLE_BLOCK_SID;
 216       return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 217
 218     case TCG2_PHYSICAL_PRESENCE_DISABLE_BLOCK_SID:
 219       PpiFlags->PPFlags &= ~TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_ENABLE_BLOCK_SID;
 220       return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 221
 222     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_TRUE:
 223       PpiFlags->PPFlags |= TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_PP_REQUIRED_FOR_ENABLE_BLOCK_SID;
 224       return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 225
 226     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_FALSE:
 227       PpiFlags->PPFlags &= ~TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_PP_REQUIRED_FOR_ENABLE_BLOCK_SID;
 228       return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 229
 230     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_TRUE:
 231       PpiFlags->PPFlags |= TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_PP_REQUIRED_FOR_DISABLE_BLOCK_SID;
 232       return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 233
 234     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_FALSE:
 235       PpiFlags->PPFlags &= ~TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_PP_REQUIRED_FOR_DISABLE_BLOCK_SID;
 236       return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 237
 238     default:
 239       if (CommandCode <= TCG2_PHYSICAL_PRESENCE_NO_ACTION_MAX) {
 240         return TCG_PP_OPERATION_RESPONSE_SUCCESS;
 241       } else {
 242         return TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
 243       }
 244   }
 245 }
 246
 247
 248 /**
 249   Read the specified key for user confirmation.
 250
 251   @param[in]  CautionKey  If true,  F12 is used as confirm key;
 252                           If false, F10 is used as confirm key.
 253
 254   @retval     TRUE        User confirmed the changes by input.
 255   @retval     FALSE       User discarded the changes.
 256 **/
 257 BOOLEAN
 258 Tcg2ReadUserKey (
 259   IN     BOOLEAN                    CautionKey
 260   )
 261 {
 262   EFI_STATUS                        Status;
 263   EFI_INPUT_KEY                     Key;
 264   UINT16                            InputKey;
 265
 266   InputKey = 0;
 267   do {
 268     Status = gBS->CheckEvent (gST->ConIn->WaitForKey);
 269     if (!EFI_ERROR (Status)) {
 270       Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 271       if (Key.ScanCode == SCAN_ESC) {
 272         InputKey = Key.ScanCode;
 273       }
 274       if ((Key.ScanCode == SCAN_F10) && !CautionKey) {
 275         InputKey = Key.ScanCode;
 276       }
 277       if ((Key.ScanCode == SCAN_F12) && CautionKey) {
 278         InputKey = Key.ScanCode;
 279       }
 280     }
 281   } while (InputKey == 0);
 282
 283   if (InputKey != SCAN_ESC) {
 284     return TRUE;
 285   }
 286
 287   return FALSE;
 288 }
 289
 290 /**
 291   Fill Buffer With BootHashAlg.
 292
 293   @param[in] Buffer               Buffer to be filled.
 294   @param[in] BufferSize           Size of buffer.
 295   @param[in] BootHashAlg          BootHashAlg.
 296
 297 **/
 298 VOID
 299 Tcg2FillBufferWithBootHashAlg (
 300   IN UINT16  *Buffer,
 301   IN UINTN   BufferSize,
 302   IN UINT32  BootHashAlg
 303   )
 304 {
 305   Buffer[0] = 0;
 306   if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SHA1) != 0) {
 307     if (Buffer[0] != 0) {
 308       StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L", ", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 309     }
 310     StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA1", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 311   }
 312   if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SHA256) != 0) {
 313     if (Buffer[0] != 0) {
 314       StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L", ", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 315     }
 316     StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA256", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 317   }
 318   if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SHA384) != 0) {
 319     if (Buffer[0] != 0) {
 320       StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L", ", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 321     }
 322     StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA384", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 323   }
 324   if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SHA512) != 0) {
 325     if (Buffer[0] != 0) {
 326       StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L", ", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 327     }
 328     StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L"SHA512", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 329   }
 330   if ((BootHashAlg & EFI_TCG2_BOOT_HASH_ALG_SM3_256) != 0) {
 331     if (Buffer[0] != 0) {
 332       StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L", ", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 333     }
 334     StrnCatS (Buffer, BufferSize / sizeof (CHAR16), L"SM3_256", (BufferSize / sizeof (CHAR16)) - StrLen (Buffer) - 1);
 335   }
 336 }
 337
 338 /**
 339   Display the confirm text and get user confirmation.
 340
 341   @param[in] TpmPpCommand             The requested TPM physical presence command.
 342   @param[in] TpmPpCommandParameter    The requested TPM physical presence command parameter.
 343
 344   @retval    TRUE          The user has confirmed the changes.
 345   @retval    FALSE         The user doesn't confirm the changes.
 346 **/
 347 BOOLEAN
 348 Tcg2UserConfirm (
 349   IN      UINT32                    TpmPpCommand,
 350   IN      UINT32                    TpmPpCommandParameter
 351   )
 352 {
 353   CHAR16                            *ConfirmText;
 354   CHAR16                            *TmpStr1;
 355   CHAR16                            *TmpStr2;
 356   UINTN                             BufSize;
 357   BOOLEAN                           CautionKey;
 358   BOOLEAN                           NoPpiInfo;
 359   UINT16                            Index;
 360   CHAR16                            DstStr[81];
 361   CHAR16                            TempBuffer[1024];
 362   CHAR16                            TempBuffer2[1024];
 363   EFI_TCG2_PROTOCOL                 *Tcg2Protocol;
 364   EFI_TCG2_BOOT_SERVICE_CAPABILITY  ProtocolCapability;
 365   UINT32                            CurrentPCRBanks;
 366   EFI_STATUS                        Status;
 367
 368   TmpStr2     = NULL;
 369   CautionKey  = FALSE;
 370   NoPpiInfo   = FALSE;
 371   BufSize     = CONFIRM_BUFFER_SIZE;
 372   ConfirmText = AllocateZeroPool (BufSize);
 373   ASSERT (ConfirmText != NULL);
 374
 375   mTcg2PpStringPackHandle = HiiAddPackages (&gEfiTcg2PhysicalPresenceGuid, gImageHandle, DxeTcg2PhysicalPresenceLibStrings, NULL);
 376   ASSERT (mTcg2PpStringPackHandle != NULL);
 377
 378   switch (TpmPpCommand) {
 379
 380     case TCG2_PHYSICAL_PRESENCE_CLEAR:
 381     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR:
 382     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_2:
 383     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_3:
 384       CautionKey = TRUE;
 385       TmpStr2 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CLEAR));
 386
 387       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
 388       UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
 389       FreePool (TmpStr1);
 390
 391       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR));
 392       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 393       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), L" \n\n", (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 394       FreePool (TmpStr1);
 395
 396       break;
 397
 398     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CLEAR_FALSE:
 399       CautionKey = TRUE;
 400       NoPpiInfo  = TRUE;
 401       TmpStr2 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CLEAR));
 402
 403       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_PPI_HEAD_STR));
 404       UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
 405       FreePool (TmpStr1);
 406
 407       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NOTE_CLEAR));
 408       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 409       FreePool (TmpStr1);
 410
 411       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CLEAR));
 412       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 413       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), L" \n\n", (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 414       FreePool (TmpStr1);
 415
 416       break;
 417
 418     case TCG2_PHYSICAL_PRESENCE_SET_PCR_BANKS:
 419       Status = gBS->LocateProtocol (&gEfiTcg2ProtocolGuid, NULL, (VOID **) &Tcg2Protocol);
 420       ASSERT_EFI_ERROR (Status);
 421
 422       ProtocolCapability.Size = sizeof(ProtocolCapability);
 423       Status = Tcg2Protocol->GetCapability (
 424                                Tcg2Protocol,
 425                                &ProtocolCapability
 426                                );
 427       ASSERT_EFI_ERROR (Status);
 428
 429       Status = Tcg2Protocol->GetActivePcrBanks (
 430                                Tcg2Protocol,
 431                                &CurrentPCRBanks
 432                                );
 433       ASSERT_EFI_ERROR (Status);
 434
 435       CautionKey = TRUE;
 436       TmpStr2 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_SET_PCR_BANKS));
 437
 438       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
 439       UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
 440       FreePool (TmpStr1);
 441
 442       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_SET_PCR_BANKS_1));
 443       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 444       FreePool (TmpStr1);
 445
 446       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_SET_PCR_BANKS_2));
 447       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 448       FreePool (TmpStr1);
 449
 450       Tcg2FillBufferWithBootHashAlg (TempBuffer, sizeof(TempBuffer), TpmPpCommandParameter);
 451       Tcg2FillBufferWithBootHashAlg (TempBuffer2, sizeof(TempBuffer2), CurrentPCRBanks);
 452
 453       TmpStr1 = AllocateZeroPool (BufSize);
 454       ASSERT (TmpStr1 != NULL);
 455       UnicodeSPrint (TmpStr1, BufSize, L"Current PCRBanks is 0x%x. (%s)\nNew PCRBanks is 0x%x. (%s)\n", CurrentPCRBanks, TempBuffer2, TpmPpCommandParameter, TempBuffer);
 456
 457       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 458       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), L" \n", (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 459       FreePool (TmpStr1);
 460
 461       break;
 462
 463     case TCG2_PHYSICAL_PRESENCE_CHANGE_EPS:
 464       CautionKey = TRUE;
 465       TmpStr2 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CHANGE_EPS));
 466
 467       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_HEAD_STR));
 468       UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
 469       FreePool (TmpStr1);
 470
 471       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CHANGE_EPS_1));
 472       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 473       FreePool (TmpStr1);
 474
 475       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_WARNING_CHANGE_EPS_2));
 476       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 477       FreePool (TmpStr1);
 478
 479       break;
 480
 481     case TCG2_PHYSICAL_PRESENCE_ENABLE_BLOCK_SID:
 482       TmpStr2 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_ENABLE_BLOCK_SID));
 483
 484       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_HEAD_STR));
 485       UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
 486       FreePool (TmpStr1);
 487       break;
 488
 489     case TCG2_PHYSICAL_PRESENCE_DISABLE_BLOCK_SID:
 490       TmpStr2 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_DISABLE_BLOCK_SID));
 491
 492       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_HEAD_STR));
 493       UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
 494       FreePool (TmpStr1);
 495       break;
 496
 497     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_FALSE:
 498       NoPpiInfo  = TRUE;
 499       TmpStr2 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_PP_ENABLE_BLOCK_SID));
 500
 501       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_PPI_HEAD_STR));
 502       UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
 503       FreePool (TmpStr1);
 504       break;
 505
 506     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_FALSE:
 507       NoPpiInfo  = TRUE;
 508       TmpStr2 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_PP_DISABLE_BLOCK_SID));
 509
 510       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_PPI_HEAD_STR));
 511       UnicodeSPrint (ConfirmText, BufSize, TmpStr1, TmpStr2);
 512       FreePool (TmpStr1);
 513       break;
 514
 515     default:
 516       ;
 517   }
 518
 519   if (TmpStr2 == NULL) {
 520     FreePool (ConfirmText);
 521     return FALSE;
 522   }
 523
 524   if (TpmPpCommand < TCG2_PHYSICAL_PRESENCE_STORAGE_MANAGEMENT_BEGIN) {
 525     if (CautionKey) {
 526       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_CAUTION_KEY));
 527     } else {
 528       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_ACCEPT_KEY));
 529     }
 530     StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 531     FreePool (TmpStr1);
 532
 533     if (NoPpiInfo) {
 534       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_NO_PPI_INFO));
 535       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 536       FreePool (TmpStr1);
 537     }
 538
 539     TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TPM_REJECT_KEY));
 540   } else {
 541     if (CautionKey) {
 542       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_CAUTION_KEY));
 543     } else {
 544       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_ACCEPT_KEY));
 545     }
 546     StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 547     FreePool (TmpStr1);
 548
 549     if (NoPpiInfo) {
 550       TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_NO_PPI_INFO));
 551       StrnCatS (ConfirmText, BufSize / sizeof (CHAR16), TmpStr1, (BufSize / sizeof (CHAR16)) - StrLen (ConfirmText) - 1);
 552       FreePool (TmpStr1);
 553     }
 554
 555     TmpStr1 = Tcg2PhysicalPresenceGetStringById (STRING_TOKEN (TCG_STORAGE_REJECT_KEY));
 556   }
 557   BufSize -= StrSize (ConfirmText);
 558   UnicodeSPrint (ConfirmText + StrLen (ConfirmText), BufSize, TmpStr1, TmpStr2);
 559
 560   DstStr[80] = L'\0';
 561   for (Index = 0; Index < StrLen (ConfirmText); Index += 80) {
 562     StrnCpyS (DstStr, sizeof (DstStr) / sizeof (CHAR16), ConfirmText + Index, sizeof (DstStr) / sizeof (CHAR16) - 1);
 563     Print (DstStr);
 564   }
 565
 566   FreePool (TmpStr1);
 567   FreePool (TmpStr2);
 568   FreePool (ConfirmText);
 569   HiiRemovePackages (mTcg2PpStringPackHandle);
 570
 571   if (Tcg2ReadUserKey (CautionKey)) {
 572     return TRUE;
 573   }
 574
 575   return FALSE;
 576 }
 577
 578 /**
 579   Check if there is a valid physical presence command request. Also updates parameter value
 580   to whether the requested physical presence command already confirmed by user
 581
 582    @param[in]  TcgPpData                 EFI Tcg2 Physical Presence request data.
 583    @param[in]  Flags                     The physical presence interface flags.
 584    @param[out] RequestConfirmed          If the physical presence operation command required user confirm from UI.
 585                                            True, it indicates the command doesn't require user confirm, or already confirmed
 586                                                  in last boot cycle by user.
 587                                            False, it indicates the command need user confirm from UI.
 588
 589    @retval  TRUE        Physical Presence operation command is valid.
 590    @retval  FALSE       Physical Presence operation command is invalid.
 591
 592 **/
 593 BOOLEAN
 594 Tcg2HaveValidTpmRequest  (
 595   IN      EFI_TCG2_PHYSICAL_PRESENCE       *TcgPpData,
 596   IN      EFI_TCG2_PHYSICAL_PRESENCE_FLAGS Flags,
 597   OUT     BOOLEAN                          *RequestConfirmed
 598   )
 599 {
 600   EFI_TCG2_PROTOCOL                 *Tcg2Protocol;
 601   EFI_STATUS                        Status;
 602   BOOLEAN                           IsRequestValid;
 603
 604   *RequestConfirmed = FALSE;
 605
 606   if (TcgPpData->PPRequest <= TCG2_PHYSICAL_PRESENCE_NO_ACTION_MAX) {
 607     //
 608     // Need TCG2 protocol.
 609     //
 610     Status = gBS->LocateProtocol (&gEfiTcg2ProtocolGuid, NULL, (VOID **) &Tcg2Protocol);
 611     if (EFI_ERROR (Status)) {
 612       return FALSE;
 613     }
 614   }
 615
 616   switch (TcgPpData->PPRequest) {
 617     case TCG2_PHYSICAL_PRESENCE_NO_ACTION:
 618       *RequestConfirmed = TRUE;
 619       return TRUE;
 620
 621     case TCG2_PHYSICAL_PRESENCE_CLEAR:
 622     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR:
 623     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_2:
 624     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_3:
 625       if ((Flags.PPFlags & TCG2_BIOS_TPM_MANAGEMENT_FLAG_PP_REQUIRED_FOR_CLEAR) == 0) {
 626         *RequestConfirmed = TRUE;
 627       }
 628       break;
 629
 630     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CLEAR_TRUE:
 631       *RequestConfirmed = TRUE;
 632       break;
 633
 634     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CLEAR_FALSE:
 635       break;
 636
 637     case TCG2_PHYSICAL_PRESENCE_SET_PCR_BANKS:
 638       if ((Flags.PPFlags & TCG2_BIOS_TPM_MANAGEMENT_FLAG_PP_REQUIRED_FOR_CHANGE_PCRS) == 0) {
 639         *RequestConfirmed = TRUE;
 640       }
 641       break;
 642
 643     case TCG2_PHYSICAL_PRESENCE_CHANGE_EPS:
 644       if ((Flags.PPFlags & TCG2_BIOS_TPM_MANAGEMENT_FLAG_PP_REQUIRED_FOR_CHANGE_EPS) == 0) {
 645         *RequestConfirmed = TRUE;
 646       }
 647       break;
 648
 649     case TCG2_PHYSICAL_PRESENCE_LOG_ALL_DIGESTS:
 650       *RequestConfirmed = TRUE;
 651       break;
 652
 653     case TCG2_PHYSICAL_PRESENCE_ENABLE_BLOCK_SID:
 654       if ((Flags.PPFlags & TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_PP_REQUIRED_FOR_ENABLE_BLOCK_SID) == 0) {
 655         *RequestConfirmed = TRUE;
 656       }
 657       break;
 658
 659     case TCG2_PHYSICAL_PRESENCE_DISABLE_BLOCK_SID:
 660       if ((Flags.PPFlags & TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_PP_REQUIRED_FOR_DISABLE_BLOCK_SID) == 0) {
 661         *RequestConfirmed = TRUE;
 662       }
 663       break;
 664
 665     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_TRUE:
 666     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_TRUE:
 667       *RequestConfirmed = TRUE;
 668       break;
 669
 670     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_FALSE:
 671     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_FALSE:
 672       break;
 673
 674     default:
 675       if (TcgPpData->PPRequest >= TCG2_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION) {
 676         IsRequestValid = Tcg2PpVendorLibHasValidRequest (TcgPpData->PPRequest, Flags.PPFlags, RequestConfirmed);
 677         if (!IsRequestValid) {
 678           return FALSE;
 679         } else {
 680           break;
 681         }
 682       } else {
 683         //
 684         // Wrong Physical Presence command
 685         //
 686         return FALSE;
 687       }
 688   }
 689
 690   if ((Flags.PPFlags & TCG2_LIB_PP_FLAG_RESET_TRACK) != 0) {
 691     //
 692     // It had been confirmed in last boot, it doesn't need confirm again.
 693     //
 694     *RequestConfirmed = TRUE;
 695   }
 696
 697   //
 698   // Physical Presence command is correct
 699   //
 700   return TRUE;
 701 }
 702
 703
 704 /**
 705   Check and execute the requested physical presence command.
 706
 707   Caution: This function may receive untrusted input.
 708   TcgPpData variable is external input, so this function will validate
 709   its data structure to be valid value.
 710
 711   @param[in]      PlatformAuth      platform auth value. NULL means no platform auth change.
 712   @param[in, out] TcgPpData         Pointer to the physical presence NV variable.
 713   @param[in, out] Flags             Pointer to the physical presence interface flags.
 714 **/
 715 VOID
 716 Tcg2ExecutePendingTpmRequest (
 717   IN      TPM2B_AUTH                       *PlatformAuth,  OPTIONAL
 718   IN OUT  EFI_TCG2_PHYSICAL_PRESENCE       *TcgPpData,
 719   IN OUT  EFI_TCG2_PHYSICAL_PRESENCE_FLAGS *Flags
 720   )
 721 {
 722   EFI_STATUS                        Status;
 723   UINTN                             DataSize;
 724   BOOLEAN                           RequestConfirmed;
 725   EFI_TCG2_PHYSICAL_PRESENCE_FLAGS  NewFlags;
 726   BOOLEAN                           ResetRequired;
 727   UINT32                            NewPPFlags;
 728
 729   if (TcgPpData->PPRequest == TCG2_PHYSICAL_PRESENCE_NO_ACTION) {
 730     //
 731     // No operation request
 732     //
 733     return;
 734   }
 735
 736   if (!Tcg2HaveValidTpmRequest(TcgPpData, *Flags, &RequestConfirmed)) {
 737     //
 738     // Invalid operation request.
 739     //
 740     if (TcgPpData->PPRequest <= TCG2_PHYSICAL_PRESENCE_NO_ACTION_MAX) {
 741       TcgPpData->PPResponse = TCG_PP_OPERATION_RESPONSE_SUCCESS;
 742     } else {
 743       TcgPpData->PPResponse = TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE;
 744     }
 745     TcgPpData->LastPPRequest = TcgPpData->PPRequest;
 746     TcgPpData->PPRequest = TCG2_PHYSICAL_PRESENCE_NO_ACTION;
 747     TcgPpData->PPRequestParameter = 0;
 748
 749     DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE);
 750     Status = gRT->SetVariable (
 751                     TCG2_PHYSICAL_PRESENCE_VARIABLE,
 752                     &gEfiTcg2PhysicalPresenceGuid,
 753                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 754                     DataSize,
 755                     TcgPpData
 756                     );
 757     return;
 758   }
 759
 760   ResetRequired = FALSE;
 761   if (TcgPpData->PPRequest >= TCG2_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION) {
 762     NewFlags = *Flags;
 763     NewPPFlags = NewFlags.PPFlags;
 764     TcgPpData->PPResponse = Tcg2PpVendorLibExecutePendingRequest (PlatformAuth, TcgPpData->PPRequest, &NewPPFlags, &ResetRequired);
 765     NewFlags.PPFlags = NewPPFlags;
 766   } else {
 767     if (!RequestConfirmed) {
 768       //
 769       // Print confirm text and wait for approval.
 770       //
 771       RequestConfirmed = Tcg2UserConfirm (TcgPpData->PPRequest, TcgPpData->PPRequestParameter);
 772     }
 773
 774     //
 775     // Execute requested physical presence command
 776     //
 777     TcgPpData->PPResponse = TCG_PP_OPERATION_RESPONSE_USER_ABORT;
 778     NewFlags = *Flags;
 779     if (RequestConfirmed) {
 780       TcgPpData->PPResponse = Tcg2ExecutePhysicalPresence (
 781                                 PlatformAuth,
 782                                 TcgPpData->PPRequest,
 783                                 TcgPpData->PPRequestParameter,
 784                                 &NewFlags
 785                                 );
 786     }
 787   }
 788
 789   //
 790   // Save the flags if it is updated.
 791   //
 792   if (CompareMem (Flags, &NewFlags, sizeof(EFI_TCG2_PHYSICAL_PRESENCE_FLAGS)) != 0) {
 793     *Flags = NewFlags;
 794     Status   = gRT->SetVariable (
 795                       TCG2_PHYSICAL_PRESENCE_FLAGS_VARIABLE,
 796                       &gEfiTcg2PhysicalPresenceGuid,
 797                       EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 798                       sizeof (EFI_TCG2_PHYSICAL_PRESENCE_FLAGS),
 799                       &NewFlags
 800                       );
 801   }
 802
 803   //
 804   // Clear request
 805   //
 806   if ((NewFlags.PPFlags & TCG2_LIB_PP_FLAG_RESET_TRACK) == 0) {
 807     TcgPpData->LastPPRequest = TcgPpData->PPRequest;
 808     TcgPpData->PPRequest = TCG2_PHYSICAL_PRESENCE_NO_ACTION;
 809     TcgPpData->PPRequestParameter = 0;
 810   }
 811
 812   //
 813   // Save changes
 814   //
 815   DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE);
 816   Status = gRT->SetVariable (
 817                   TCG2_PHYSICAL_PRESENCE_VARIABLE,
 818                   &gEfiTcg2PhysicalPresenceGuid,
 819                   EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 820                   DataSize,
 821                   TcgPpData
 822                   );
 823   if (EFI_ERROR (Status)) {
 824     return;
 825   }
 826
 827   if (TcgPpData->PPResponse == TCG_PP_OPERATION_RESPONSE_USER_ABORT) {
 828     return;
 829   }
 830
 831   //
 832   // Reset system to make new TPM settings in effect
 833   //
 834   switch (TcgPpData->LastPPRequest) {
 835     case TCG2_PHYSICAL_PRESENCE_CLEAR:
 836     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR:
 837     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_2:
 838     case TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_3:
 839     case TCG2_PHYSICAL_PRESENCE_SET_PCR_BANKS:
 840     case TCG2_PHYSICAL_PRESENCE_CHANGE_EPS:
 841     case TCG2_PHYSICAL_PRESENCE_LOG_ALL_DIGESTS:
 842       break;
 843
 844     case TCG2_PHYSICAL_PRESENCE_ENABLE_BLOCK_SID:
 845     case TCG2_PHYSICAL_PRESENCE_DISABLE_BLOCK_SID:
 846       break;
 847
 848     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_TRUE:
 849     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_TRUE:
 850     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_FALSE:
 851     case TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_FALSE:
 852       return;
 853
 854     default:
 855       if (TcgPpData->LastPPRequest >= TCG2_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION) {
 856         if (ResetRequired) {
 857           break;
 858         } else {
 859           return ;
 860         }
 861       }
 862       if (TcgPpData->PPRequest != TCG2_PHYSICAL_PRESENCE_NO_ACTION) {
 863         break;
 864       }
 865       return;
 866   }
 867
 868   Print (L"Rebooting system to make TPM2 settings in effect\n");
 869   gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
 870   ASSERT (FALSE);
 871 }
 872
 873 /**
 874   Check and execute the pending TPM request.
 875
 876   The TPM request may come from OS or BIOS. This API will display request information and wait
 877   for user confirmation if TPM request exists. The TPM request will be sent to TPM device after
 878   the TPM request is confirmed, and one or more reset may be required to make TPM request to
 879   take effect.
 880
 881   This API should be invoked after console in and console out are all ready as they are required
 882   to display request information and get user input to confirm the request.
 883
 884   @param[in]  PlatformAuth                   platform auth value. NULL means no platform auth change.
 885 **/
 886 VOID
 887 EFIAPI
 888 Tcg2PhysicalPresenceLibProcessRequest (
 889   IN      TPM2B_AUTH                     *PlatformAuth  OPTIONAL
 890   )
 891 {
 892   EFI_STATUS                        Status;
 893   UINTN                             DataSize;
 894   EFI_TCG2_PHYSICAL_PRESENCE        TcgPpData;
 895   EDKII_VARIABLE_LOCK_PROTOCOL      *VariableLockProtocol;
 896   EFI_TCG2_PHYSICAL_PRESENCE_FLAGS  PpiFlags;
 897
 898   //
 899   // This flags variable controls whether physical presence is required for TPM command.
 900   // It should be protected from malicious software. We set it as read-only variable here.
 901   //
 902   Status = gBS->LocateProtocol (&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLockProtocol);
 903   if (!EFI_ERROR (Status)) {
 904     Status = VariableLockProtocol->RequestToLock (
 905                                      VariableLockProtocol,
 906                                      TCG2_PHYSICAL_PRESENCE_FLAGS_VARIABLE,
 907                                      &gEfiTcg2PhysicalPresenceGuid
 908                                      );
 909     if (EFI_ERROR (Status)) {
 910       DEBUG ((EFI_D_ERROR, "[TPM2] Error when lock variable %s, Status = %r\n", TCG2_PHYSICAL_PRESENCE_FLAGS_VARIABLE, Status));
 911       ASSERT_EFI_ERROR (Status);
 912     }
 913   }
 914
 915   //
 916   // Check S4 resume
 917   //
 918   if (GetBootModeHob () == BOOT_ON_S4_RESUME) {
 919     DEBUG ((EFI_D_INFO, "S4 Resume, Skip TPM PP process!\n"));
 920     return ;
 921   }
 922
 923   //
 924   // Initialize physical presence flags.
 925   //
 926   DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE_FLAGS);
 927   Status = gRT->GetVariable (
 928                   TCG2_PHYSICAL_PRESENCE_FLAGS_VARIABLE,
 929                   &gEfiTcg2PhysicalPresenceGuid,
 930                   NULL,
 931                   &DataSize,
 932                   &PpiFlags
 933                   );
 934   if (EFI_ERROR (Status)) {
 935     PpiFlags.PPFlags = PcdGet32(PcdTcg2PhysicalPresenceFlags);
 936     Status   = gRT->SetVariable (
 937                       TCG2_PHYSICAL_PRESENCE_FLAGS_VARIABLE,
 938                       &gEfiTcg2PhysicalPresenceGuid,
 939                       EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 940                       sizeof (EFI_TCG2_PHYSICAL_PRESENCE_FLAGS),
 941                       &PpiFlags
 942                       );
 943     if (EFI_ERROR (Status)) {
 944       DEBUG ((EFI_D_ERROR, "[TPM2] Set physical presence flag failed, Status = %r\n", Status));
 945       return ;
 946     }
 947     DEBUG((DEBUG_INFO, "[TPM2] Initial physical presence flags value is 0x%x\n", PpiFlags.PPFlags));
 948   }
 949
 950   //
 951   // Initialize physical presence variable.
 952   //
 953   DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE);
 954   Status = gRT->GetVariable (
 955                   TCG2_PHYSICAL_PRESENCE_VARIABLE,
 956                   &gEfiTcg2PhysicalPresenceGuid,
 957                   NULL,
 958                   &DataSize,
 959                   &TcgPpData
 960                   );
 961   if (EFI_ERROR (Status)) {
 962     ZeroMem ((VOID*)&TcgPpData, sizeof (TcgPpData));
 963     DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE);
 964     Status   = gRT->SetVariable (
 965                       TCG2_PHYSICAL_PRESENCE_VARIABLE,
 966                       &gEfiTcg2PhysicalPresenceGuid,
 967                       EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 968                       DataSize,
 969                       &TcgPpData
 970                       );
 971     if (EFI_ERROR (Status)) {
 972       DEBUG ((EFI_D_ERROR, "[TPM2] Set physical presence variable failed, Status = %r\n", Status));
 973       return ;
 974     }
 975   }
 976
 977   DEBUG ((EFI_D_INFO, "[TPM2] Flags=%x, PPRequest=%x (LastPPRequest=%x)\n", PpiFlags.PPFlags, TcgPpData.PPRequest, TcgPpData.LastPPRequest));
 978
 979   //
 980   // Execute pending TPM request.
 981   //
 982   Tcg2ExecutePendingTpmRequest (PlatformAuth, &TcgPpData, &PpiFlags);
 983   DEBUG ((EFI_D_INFO, "[TPM2] PPResponse = %x (LastPPRequest=%x, Flags=%x)\n", TcgPpData.PPResponse, TcgPpData.LastPPRequest, PpiFlags.PPFlags));
 984
 985 }
 986
 987 /**
 988   Check if the pending TPM request needs user input to confirm.
 989
 990   The TPM request may come from OS. This API will check if TPM request exists and need user
 991   input to confirmation.
 992
 993   @retval    TRUE        TPM needs input to confirm user physical presence.
 994   @retval    FALSE       TPM doesn't need input to confirm user physical presence.
 995
 996 **/
 997 BOOLEAN
 998 EFIAPI
 999 Tcg2PhysicalPresenceLibNeedUserConfirm(
1000   VOID
1001   )
1002 {
1003   EFI_STATUS                        Status;
1004   EFI_TCG2_PHYSICAL_PRESENCE        TcgPpData;
1005   UINTN                             DataSize;
1006   BOOLEAN                           RequestConfirmed;
1007   EFI_TCG2_PHYSICAL_PRESENCE_FLAGS  PpiFlags;
1008
1009   //
1010   // Check S4 resume
1011   //
1012   if (GetBootModeHob () == BOOT_ON_S4_RESUME) {
1013     DEBUG ((EFI_D_INFO, "S4 Resume, Skip TPM PP process!\n"));
1014     return FALSE;
1015   }
1016
1017   //
1018   // Check Tpm requests
1019   //
1020   DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE);
1021   Status = gRT->GetVariable (
1022                   TCG2_PHYSICAL_PRESENCE_VARIABLE,
1023                   &gEfiTcg2PhysicalPresenceGuid,
1024                   NULL,
1025                   &DataSize,
1026                   &TcgPpData
1027                   );
1028   if (EFI_ERROR (Status)) {
1029     return FALSE;
1030   }
1031
1032   DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE_FLAGS);
1033   Status = gRT->GetVariable (
1034                   TCG2_PHYSICAL_PRESENCE_FLAGS_VARIABLE,
1035                   &gEfiTcg2PhysicalPresenceGuid,
1036                   NULL,
1037                   &DataSize,
1038                   &PpiFlags
1039                   );
1040   if (EFI_ERROR (Status)) {
1041     return FALSE;
1042   }
1043
1044   if (TcgPpData.PPRequest == TCG2_PHYSICAL_PRESENCE_NO_ACTION) {
1045     //
1046     // No operation request
1047     //
1048     return FALSE;
1049   }
1050
1051   if (!Tcg2HaveValidTpmRequest(&TcgPpData, PpiFlags, &RequestConfirmed)) {
1052     //
1053     // Invalid operation request.
1054     //
1055     return FALSE;
1056   }
1057
1058   if (!RequestConfirmed) {
1059     //
1060     // Need UI to confirm
1061     //
1062     return TRUE;
1063   }
1064
1065   return FALSE;
1066 }
1067
1068
1069 /**
1070   The handler for TPM physical presence function:
1071   Return TPM Operation Response to OS Environment.
1072
1073   @param[out]     MostRecentRequest Most recent operation request.
1074   @param[out]     Response          Response to the most recent operation request.
1075
1076   @return Return Code for Return TPM Operation Response to OS Environment.
1077 **/
1078 UINT32
1079 EFIAPI
1080 Tcg2PhysicalPresenceLibReturnOperationResponseToOsFunction (
1081   OUT UINT32                *MostRecentRequest,
1082   OUT UINT32                *Response
1083   )
1084 {
1085   EFI_STATUS                        Status;
1086   UINTN                             DataSize;
1087   EFI_TCG2_PHYSICAL_PRESENCE        PpData;
1088
1089   DEBUG ((EFI_D_INFO, "[TPM2] ReturnOperationResponseToOsFunction\n"));
1090
1091   //
1092   // Get the Physical Presence variable
1093   //
1094   DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE);
1095   Status = gRT->GetVariable (
1096                   TCG2_PHYSICAL_PRESENCE_VARIABLE,
1097                   &gEfiTcg2PhysicalPresenceGuid,
1098                   NULL,
1099                   &DataSize,
1100                   &PpData
1101                   );
1102   if (EFI_ERROR (Status)) {
1103     *MostRecentRequest = 0;
1104     *Response          = 0;
1105     DEBUG ((EFI_D_ERROR, "[TPM2] Get PP variable failure! Status = %r\n", Status));
1106     return TCG_PP_RETURN_TPM_OPERATION_RESPONSE_FAILURE;
1107   }
1108
1109   *MostRecentRequest = PpData.LastPPRequest;
1110   *Response          = PpData.PPResponse;
1111
1112   return TCG_PP_RETURN_TPM_OPERATION_RESPONSE_SUCCESS;
1113 }
1114
1115 /**
1116   The handler for TPM physical presence function:
1117   Submit TPM Operation Request to Pre-OS Environment and
1118   Submit TPM Operation Request to Pre-OS Environment 2.
1119
1120   Caution: This function may receive untrusted input.
1121
1122   @param[in]      OperationRequest TPM physical presence operation request.
1123   @param[in]      RequestParameter TPM physical presence operation request parameter.
1124
1125   @return Return Code for Submit TPM Operation Request to Pre-OS Environment and
1126           Submit TPM Operation Request to Pre-OS Environment 2.
1127 **/
1128 UINT32
1129 EFIAPI
1130 Tcg2PhysicalPresenceLibSubmitRequestToPreOSFunction (
1131   IN UINT32                 OperationRequest,
1132   IN UINT32                 RequestParameter
1133   )
1134 {
1135   EFI_STATUS                        Status;
1136   UINTN                             DataSize;
1137   EFI_TCG2_PHYSICAL_PRESENCE        PpData;
1138   EFI_TCG2_PHYSICAL_PRESENCE_FLAGS  Flags;
1139
1140   DEBUG ((EFI_D_INFO, "[TPM2] SubmitRequestToPreOSFunction, Request = %x, %x\n", OperationRequest, RequestParameter));
1141
1142   //
1143   // Get the Physical Presence variable
1144   //
1145   DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE);
1146   Status = gRT->GetVariable (
1147                   TCG2_PHYSICAL_PRESENCE_VARIABLE,
1148                   &gEfiTcg2PhysicalPresenceGuid,
1149                   NULL,
1150                   &DataSize,
1151                   &PpData
1152                   );
1153   if (EFI_ERROR (Status)) {
1154     DEBUG ((EFI_D_ERROR, "[TPM2] Get PP variable failure! Status = %r\n", Status));
1155     return TCG_PP_SUBMIT_REQUEST_TO_PREOS_GENERAL_FAILURE;
1156   }
1157
1158   if ((OperationRequest > TCG2_PHYSICAL_PRESENCE_NO_ACTION_MAX) &&
1159       (OperationRequest < TCG2_PHYSICAL_PRESENCE_STORAGE_MANAGEMENT_BEGIN) ) {
1160     return TCG_PP_SUBMIT_REQUEST_TO_PREOS_NOT_IMPLEMENTED;
1161   }
1162
1163   if ((PpData.PPRequest != OperationRequest) ||
1164       (PpData.PPRequestParameter != RequestParameter)) {
1165     PpData.PPRequest = (UINT8)OperationRequest;
1166     PpData.PPRequestParameter = RequestParameter;
1167     DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE);
1168     Status = gRT->SetVariable (
1169                     TCG2_PHYSICAL_PRESENCE_VARIABLE,
1170                     &gEfiTcg2PhysicalPresenceGuid,
1171                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1172                     DataSize,
1173                     &PpData
1174                     );
1175     if (EFI_ERROR (Status)) {
1176       DEBUG ((EFI_D_ERROR, "[TPM2] Set PP variable failure! Status = %r\n", Status));
1177       return TCG_PP_SUBMIT_REQUEST_TO_PREOS_GENERAL_FAILURE;
1178     }
1179   }
1180
1181   if (OperationRequest >= TCG2_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION) {
1182     DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE_FLAGS);
1183     Status = gRT->GetVariable (
1184                     TCG2_PHYSICAL_PRESENCE_FLAGS_VARIABLE,
1185                     &gEfiTcg2PhysicalPresenceGuid,
1186                     NULL,
1187                     &DataSize,
1188                     &Flags
1189                     );
1190     if (EFI_ERROR (Status)) {
1191       Flags.PPFlags = TCG2_BIOS_TPM_MANAGEMENT_FLAG_DEFAULT | TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_DEFAULT;
1192     }
1193     return Tcg2PpVendorLibSubmitRequestToPreOSFunction (OperationRequest, Flags.PPFlags, RequestParameter);
1194   }
1195
1196   return TCG_PP_SUBMIT_REQUEST_TO_PREOS_SUCCESS;
1197 }
1198
1199 /**
1200   Return TPM2 ManagementFlags set by PP interface.
1201
1202   @retval    ManagementFlags    TPM2 Management Flags.
1203 **/
1204 UINT32
1205 EFIAPI
1206 Tcg2PhysicalPresenceLibGetManagementFlags (
1207   VOID
1208   )
1209 {
1210   EFI_STATUS                        Status;
1211   EFI_TCG2_PHYSICAL_PRESENCE_FLAGS  PpiFlags;
1212   UINTN                             DataSize;
1213
1214   DEBUG ((EFI_D_INFO, "[TPM2] GetManagementFlags\n"));
1215
1216   DataSize = sizeof (EFI_TCG2_PHYSICAL_PRESENCE_FLAGS);
1217   Status = gRT->GetVariable (
1218                   TCG2_PHYSICAL_PRESENCE_FLAGS_VARIABLE,
1219                   &gEfiTcg2PhysicalPresenceGuid,
1220                   NULL,
1221                   &DataSize,
1222                   &PpiFlags
1223                   );
1224   if (EFI_ERROR (Status)) {
1225     PpiFlags.PPFlags = TCG2_BIOS_TPM_MANAGEMENT_FLAG_DEFAULT | TCG2_BIOS_STORAGE_MANAGEMENT_FLAG_DEFAULT;
1226   }
1227   return PpiFlags.PPFlags;
1228 }