tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SecurityPkg/TcgDxe: Use updated Tpm12CommandLib APIs 

Use the following new APIs in Tpm12CommandLib and remove duplicate
code from TcgPei and TcgDxe:
  Tpm12Extend()
  Tpm12PhysicalPresence()
  Tpm12ContinueSelfTest()
  Tpm12GetCapabilityFlagPermanent()
  Tpm12GetCapabilityFlagVolatile()

Cc: Chao Zhang <chao.b.zhang@intel.com>
Cc: Jiewen Yao <jiewen.yao@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Michael Kinney <michael.d.kinney@intel.com>
Reviewed-by: Chao Zhang <chao.b.zhang@intel.com>
Reviewed-by: Jiewen Yao <jiewen.yao@intel.com>

git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@19729 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
Michael Kinney 2016-01-21 19:30:21 +00:00 committed by mdkinney
parent 45500265b3
commit 441a3678e1
5 changed files with 94 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
SecurityPkg/Tcg/TcgDxe/TcgDxe.c
View File

@ -50,8 +50,8 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#include <Library/PcdLib.h>
#include <Library/UefiLib.h>
#include <Library/ReportStatusCodeLib.h>
#include "TpmComm.h"
#include <Library/Tpm12CommandLib.h>
#include <Library/BaseCryptLib.h>
#define TCG_DXE_DATA_FROM_THIS(this) \
BASE_CR (this, TCG_DXE_DATA, TcgProtocol)
@ -270,6 +270,40 @@ TcgDxeStatusCheck (
return EFI_SUCCESS;
}
/**
Single function calculates SHA1 digest value for all raw data. It
combines Sha1Init(), Sha1Update() and Sha1Final().
@param[in] Data Raw data to be digested.
@param[in] DataLen Size of the raw data.
@param[out] Digest Pointer to a buffer that stores the final digest.
@retval EFI_SUCCESS Always successfully calculate the final digest.
**/
EFI_STATUS
EFIAPI
TpmCommHashAll (
IN CONST UINT8 *Data,
IN UINTN DataLen,
OUT TPM_DIGEST *Digest
)
{
VOID *Sha1Ctx;
UINTN CtxSize;
CtxSize = Sha1GetContextSize ();
Sha1Ctx = AllocatePool (CtxSize);
ASSERT (Sha1Ctx != NULL);
Sha1Init (Sha1Ctx);
Sha1Update (Sha1Ctx, Data, DataLen);
Sha1Final (Sha1Ctx, (UINT8 *)Digest);
FreePool (Sha1Ctx);
return EFI_SUCCESS;
}
/**
This service abstracts the capability to do a hash operation on a data buffer.
@ -333,6 +367,53 @@ TcgDxeHashAll (
}
}
/**
Add a new entry to the Event Log.
@param[in, out] EventLogPtr Pointer to the Event Log data.
@param[in, out] LogSize Size of the Event Log.
@param[in] MaxSize Maximum size of the Event Log.
@param[in] NewEventHdr Pointer to a TCG_PCR_EVENT_HDR data structure.
@param[in] NewEventData Pointer to the new event data.
@retval EFI_SUCCESS The new event log entry was added.
@retval EFI_OUT_OF_RESOURCES No enough memory to log the new event.
**/
EFI_STATUS
TpmCommLogEvent (
IN OUT UINT8 **EventLogPtr,
IN OUT UINTN *LogSize,
IN UINTN MaxSize,
IN TCG_PCR_EVENT_HDR *NewEventHdr,
IN UINT8 *NewEventData
)
{
UINTN NewLogSize;
//
// Prevent Event Overflow
//
if (NewEventHdr->EventSize > (UINTN)(~0) - sizeof (*NewEventHdr)) {
return EFI_OUT_OF_RESOURCES;
}
NewLogSize = sizeof (*NewEventHdr) + NewEventHdr->EventSize;
if (NewLogSize > MaxSize - *LogSize) {
return EFI_OUT_OF_RESOURCES;
}
*EventLogPtr += *LogSize;
*LogSize += NewLogSize;
CopyMem (*EventLogPtr, NewEventHdr, sizeof (*NewEventHdr));
CopyMem (
*EventLogPtr + sizeof (*NewEventHdr),
NewEventData,
NewEventHdr->EventSize
);
return EFI_SUCCESS;
}
/**
Add a new entry to the Event Log.
@ -442,8 +523,6 @@ TcgDxePassThroughToTpm (
IN UINT8 *TpmOutputParameterBlock
)
{
TCG_DXE_DATA *TcgData;
if (TpmInputParameterBlock == NULL ||
TpmOutputParameterBlock == NULL ||
TpmInputParameterBlockSize == 0 ||
@ -451,14 +530,11 @@ TcgDxePassThroughToTpm (
return EFI_INVALID_PARAMETER;
}
TcgData = TCG_DXE_DATA_FROM_THIS (This);
return TisPcExecute (
"%r%/%r",
return Tpm12SubmitCommand (
TpmInputParameterBlockSize,
TpmInputParameterBlock,
(UINTN) TpmInputParameterBlockSize,
TpmOutputParameterBlock,
(UINTN) TpmOutputParameterBlockSize
&TpmOutputParameterBlockSize,
TpmOutputParameterBlock
);
}
@ -506,7 +582,7 @@ TcgDxeHashLogExtendEventI (
}
}
Status = TpmCommExtend (
Status = Tpm12Extend (
&NewEventHdr->Digest,
NewEventHdr->PCRIndex,
NULL
@ -1272,19 +1348,15 @@ OnExitBootServicesFailed (
**/
EFI_STATUS
GetTpmStatus (
OUT BOOLEAN *TPMDeactivatedFlag
OUT BOOLEAN *TPMDeactivatedFlag
)
{
EFI_STATUS Status;
TPM_STCLEAR_FLAGS VFlags;
EFI_STATUS Status;
TPM_STCLEAR_FLAGS VolatileFlags;
Status = TpmCommGetFlags (
TPM_CAP_FLAG_VOLATILE,
&VFlags,
sizeof (VFlags)
);
Status = Tpm12GetCapabilityFlagVolatile (&VolatileFlags);
if (!EFI_ERROR (Status)) {
*TPMDeactivatedFlag = VFlags.deactivated;
*TPMDeactivatedFlag = VolatileFlags.deactivated;
}
return Status;

4
SecurityPkg/Tcg/TcgDxe/TcgDxe.inf
View File

@ -29,9 +29,6 @@
[Sources]
TcgDxe.c
TisDxe.c
TpmComm.c
TpmComm.h
[Packages]
MdePkg/MdePkg.dec
@ -54,6 +51,7 @@
UefiLib
PcdLib
ReportStatusCodeLib
Tpm12CommandLib
[Guids]
gEfiGlobalVariableGuid ## SOMETIMES_CONSUMES ## Variable:L"BootXXXX"

298
SecurityPkg/Tcg/TcgDxe/TisDxe.c
View File

@ -1,298 +0,0 @@
/** @file
TIS (TPM Interface Specification) functions used by TPM Dxe driver.
Copyright (c) 2005 - 2016, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include <IndustryStandard/Tpm12.h>
#include <Library/TimerLib.h>
#include <Library/Tpm12DeviceLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
//
// Max TPM command/reponse length
//
#define TPMCMDBUFLENGTH SIZE_1KB
STATIC UINT8 TpmCommandBuf[TPMCMDBUFLENGTH];
STATIC UINT8 TpmResponseBuf[TPMCMDBUFLENGTH];
/**
Format TPM command data according to the format control character.
@param[in] FmtChar Format control character.
@param[in, out] ap List of arguments.
@param[in] TpmBuffer Buffer for TPM command data.
@param[out] DataLength TPM command data length.
@retval EFI_SUCCESS Operation completed successfully.
@retval EFI_INVALID_PARAMETER Invalid format control character.
@retval EFI_BUFFER_TOO_SMALL Buffer too small for command data.
**/
EFI_STATUS
TisPcSendV (
IN UINT8 FmtChar,
IN OUT VA_LIST *ap,
UINT8 *TpmBuffer,
UINT32 *DataLength
)
{
UINT8 DataByte;
UINT16 DataWord;
UINT32 DataDword;
TPM_RQU_COMMAND_HDR TpmCmdHdr;
TPM_RQU_COMMAND_HDR *TpmCmdPtr;
UINTN Size;
UINT8 *Raw;
switch (FmtChar) {
case 'b':
DataByte = VA_ARG (*ap, UINT8);
Raw = &DataByte;
Size = sizeof (DataByte);
break;
case 'w':
DataWord = VA_ARG (*ap, UINT16);
DataWord = SwapBytes16 (DataWord);
Raw = (UINT8*)&DataWord;
Size = sizeof (DataWord);
break;
case 'd':
DataDword = VA_ARG (*ap, UINT32);
DataDword = SwapBytes32 (DataDword);
Raw = (UINT8*)&DataDword;
Size = sizeof (DataDword);
break;
case 'h':
TpmCmdPtr = VA_ARG (*ap, TPM_RQU_COMMAND_HDR*);
TpmCmdHdr.tag = SwapBytes16 (TpmCmdPtr->tag);
TpmCmdHdr.paramSize = SwapBytes32 (TpmCmdPtr->paramSize);
TpmCmdHdr.ordinal = SwapBytes32 (TpmCmdPtr->ordinal);
Raw = (UINT8*) &TpmCmdHdr;
Size = sizeof (TpmCmdHdr);
break;
case 'r':
Raw = VA_ARG (*ap, UINT8*);
Size = VA_ARG (*ap, UINTN);
break;
case '\0':
return EFI_INVALID_PARAMETER;
default:
return EFI_INVALID_PARAMETER;
}
//
// Check input to avoid overflow.
//
if ((UINT32) (~0)- *DataLength < (UINT32)Size) {
return EFI_INVALID_PARAMETER;
}
if(*DataLength + (UINT32) Size > TPMCMDBUFLENGTH) {
return EFI_BUFFER_TOO_SMALL;
}
CopyMem (TpmBuffer + *DataLength, Raw, Size);
*DataLength += (UINT32) Size;
return EFI_SUCCESS;
}
/**
Format reponse data according to the format control character.
@param[in] FmtChar Format control character.
@param[in, out] ap List of arguments.
@param[out] TpmBuffer Buffer for reponse data.
@param[in, out] DataIndex Data offset in reponse data buffer.
@param[in] RespSize Response data length.
@param[out] DataFinished Reach the end of Response data.
@retval EFI_SUCCESS Operation completed successfully.
@retval EFI_INVALID_PARAMETER Invalid format control character.
@retval EFI_BUFFER_TOO_SMALL Buffer too small for command data.
**/
EFI_STATUS
TisPcReceiveV (
IN UINT8 FmtChar,
IN OUT VA_LIST *ap,
OUT UINT8 *TpmBuffer,
IN OUT UINT32 *DataIndex,
IN UINT32 RespSize,
OUT BOOLEAN *DataFinished
)
{
UINT8 *Raw;
TPM_RSP_COMMAND_HDR *TpmRspPtr;
UINTN Size;
Raw = VA_ARG (*ap, UINT8*);
switch (FmtChar) {
case 'b':
Size = sizeof (UINT8);
break;
case 'w':
Size = sizeof (UINT16);
break;
case 'd':
Size = sizeof (UINT32);
break;
case 'h':
Size = sizeof (*TpmRspPtr);
break;
case 'r':
Size = VA_ARG (*ap, UINTN);
//
// If overflowed, which means Size is big enough for Response data.
// skip this check. Copy the whole data
//
if ((UINT32) (~0)- *DataIndex >= (UINT32)Size) {
if(*DataIndex + (UINT32) Size <= RespSize) {
break;
}
}
*DataFinished = TRUE;
if (*DataIndex >= RespSize) {
return EFI_SUCCESS;
}
CopyMem (Raw, TpmBuffer + *DataIndex, RespSize - *DataIndex);
*DataIndex += RespSize - *DataIndex;
return EFI_SUCCESS;
case '\0':
return EFI_INVALID_PARAMETER;
default:
return EFI_WARN_UNKNOWN_GLYPH;
}
if(*DataIndex + (UINT32) Size > RespSize) {
*DataFinished = TRUE;
return EFI_SUCCESS;
}
if( *DataIndex + (UINT32) Size > TPMCMDBUFLENGTH )
return EFI_BUFFER_TOO_SMALL;
CopyMem (Raw, TpmBuffer + *DataIndex, Size);
*DataIndex += (UINT32) Size;
switch (FmtChar) {
case 'w':
*(UINT16*)Raw = SwapBytes16 (*(UINT16*) Raw);
break;
case 'd':
*(UINT32*)Raw = SwapBytes32 (*(UINT32*) Raw);
break;
case 'h':
TpmRspPtr = (TPM_RSP_COMMAND_HDR*) Raw;
TpmRspPtr->tag = SwapBytes16 (TpmRspPtr->tag);
TpmRspPtr->paramSize = SwapBytes32 (TpmRspPtr->paramSize);
TpmRspPtr->returnCode = SwapBytes32 (TpmRspPtr->returnCode);
break;
}
return EFI_SUCCESS;
}
/**
Send formatted command to TPM for execution and return formatted data from response.
@param[in] TisReg TPM Handle.
@param[in] Fmt Format control string.
@param[in] ... The variable argument list.
@retval EFI_SUCCESS Operation completed successfully.
@retval EFI_TIMEOUT The register can't run into the expected status in time.
**/
EFI_STATUS
EFIAPI
TisPcExecute (
IN CONST CHAR8 *Fmt,
...
)
{
EFI_STATUS Status;
VA_LIST Ap;
UINT32 BufSize;
UINT32 ResponseSize;
BOOLEAN DataFinished;
VA_START (Ap, Fmt);
//
// Put the formatted command to the TpmCommandBuf
//
BufSize = 0;
while (*Fmt != '\0') {
if (*Fmt == '%') Fmt++;
if (*Fmt == '/') break;
Status = TisPcSendV (*Fmt, &Ap, TpmCommandBuf, &BufSize);
if (EFI_ERROR( Status )) {
goto Error;
}
Fmt++;
}
//
// Send the command to TPM
//
ZeroMem (TpmResponseBuf, sizeof (TpmResponseBuf));
ResponseSize = sizeof (TpmResponseBuf);
Status = Tpm12SubmitCommand (BufSize, TpmCommandBuf, &ResponseSize, TpmResponseBuf);
if (EFI_ERROR (Status)) {
goto Error;
}
Fmt++;
//
// Get the formatted data from the TpmResponseBuf.
//
BufSize =0;
DataFinished = FALSE;
while (*Fmt != '\0') {
if (*Fmt == '%') {
Fmt++;
}
Status = TisPcReceiveV (*Fmt, &Ap, TpmResponseBuf, &BufSize, ResponseSize, &DataFinished);
if (EFI_ERROR (Status)) {
goto Error;
}
if (DataFinished) {
VA_END (Ap);
return EFI_SUCCESS;
}
Fmt++;
}
Error:
VA_END (Ap);
return Status;
}

200
SecurityPkg/Tcg/TcgDxe/TpmComm.c
View File

@ -1,200 +0,0 @@
/** @file
Utility functions used by TPM Dxe driver.
Copyright (c) 2005 - 2016, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include <IndustryStandard/Tpm12.h>
#include <IndustryStandard/UefiTcgPlatform.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/BaseCryptLib.h>
#include "TpmComm.h"
/**
Extend a TPM PCR.
@param[in] DigestToExtend The 160 bit value representing the event to be recorded.
@param[in] PcrIndex The PCR to be updated.
@param[out] NewPcrValue New PCR value after extend.
@retval EFI_SUCCESS Operation completed successfully.
@retval EFI_DEVICE_ERROR The command was unsuccessful.
**/
EFI_STATUS
TpmCommExtend (
IN TPM_DIGEST *DigestToExtend,
IN TPM_PCRINDEX PcrIndex,
OUT TPM_DIGEST *NewPcrValue
)
{
EFI_STATUS Status;
TPM_DIGEST NewValue;
TPM_RQU_COMMAND_HDR CmdHdr;
TPM_RSP_COMMAND_HDR RspHdr;
if (NewPcrValue == NULL) {
NewPcrValue = &NewValue;
}
CmdHdr.tag = TPM_TAG_RQU_COMMAND;
CmdHdr.paramSize =
sizeof (CmdHdr) + sizeof (PcrIndex) + sizeof (*DigestToExtend);
CmdHdr.ordinal = TPM_ORD_Extend;
Status = TisPcExecute (
"%h%d%r%/%h%r",
&CmdHdr,
PcrIndex,
DigestToExtend,
(UINTN)sizeof (*DigestToExtend),
&RspHdr,
NewPcrValue,
(UINTN)sizeof (*NewPcrValue)
);
if (EFI_ERROR (Status)) {
return Status;
}
if (RspHdr.returnCode != 0) {
return EFI_DEVICE_ERROR;
}
return EFI_SUCCESS;
}
/**
Get TPM capability flags.
@param[in] FlagSubcap Flag subcap.
@param[out] FlagBuffer Pointer to the buffer for returned flag structure.
@param[in] FlagSize Size of the buffer.
@retval EFI_SUCCESS Operation completed successfully.
@retval EFI_DEVICE_ERROR The command was unsuccessful.
**/
EFI_STATUS
TpmCommGetFlags (
IN UINT32 FlagSubcap,
OUT VOID *FlagBuffer,
IN UINTN FlagSize
)
{
EFI_STATUS Status;
TPM_RQU_COMMAND_HDR CmdHdr;
TPM_RSP_COMMAND_HDR RspHdr;
UINT32 Size;
CmdHdr.tag = TPM_TAG_RQU_COMMAND;
CmdHdr.paramSize = sizeof (CmdHdr) + sizeof (UINT32) * 3;
CmdHdr.ordinal = TPM_ORD_GetCapability;
Status = TisPcExecute (
"%h%d%d%d%/%h%d%r",
&CmdHdr,
TPM_CAP_FLAG,
sizeof (FlagSubcap),
FlagSubcap,
&RspHdr,
&Size,
FlagBuffer,
FlagSize
);
if (EFI_ERROR (Status)) {
return Status;
}
if (RspHdr.returnCode != 0) {
return EFI_DEVICE_ERROR;
}
return EFI_SUCCESS;
}
/**
Add a new entry to the Event Log.
@param[in, out] EventLogPtr Pointer to the Event Log data.
@param[in, out] LogSize Size of the Event Log.
@param[in] MaxSize Maximum size of the Event Log.
@param[in] NewEventHdr Pointer to a TCG_PCR_EVENT_HDR data structure.
@param[in] NewEventData Pointer to the new event data.
@retval EFI_SUCCESS The new event log entry was added.
@retval EFI_OUT_OF_RESOURCES No enough memory to log the new event.
**/
EFI_STATUS
TpmCommLogEvent (
IN OUT UINT8 **EventLogPtr,
IN OUT UINTN *LogSize,
IN UINTN MaxSize,
IN TCG_PCR_EVENT_HDR *NewEventHdr,
IN UINT8 *NewEventData
)
{
UINTN NewLogSize;
//
// Prevent Event Overflow
//
if (NewEventHdr->EventSize > (UINTN)(~0) - sizeof (*NewEventHdr)) {
return EFI_OUT_OF_RESOURCES;
}
NewLogSize = sizeof (*NewEventHdr) + NewEventHdr->EventSize;
if (NewLogSize > MaxSize - *LogSize) {
return EFI_OUT_OF_RESOURCES;
}
*EventLogPtr += *LogSize;
*LogSize += NewLogSize;
CopyMem (*EventLogPtr, NewEventHdr, sizeof (*NewEventHdr));
CopyMem (
*EventLogPtr + sizeof (*NewEventHdr),
NewEventData,
NewEventHdr->EventSize
);
return EFI_SUCCESS;
}
/**
Single function calculates SHA1 digest value for all raw data. It
combines Sha1Init(), Sha1Update() and Sha1Final().
@param[in] Data Raw data to be digested.
@param[in] DataLen Size of the raw data.
@param[out] Digest Pointer to a buffer that stores the final digest.
@retval EFI_SUCCESS Always successfully calculate the final digest.
**/
EFI_STATUS
EFIAPI
TpmCommHashAll (
IN CONST UINT8 *Data,
IN UINTN DataLen,
OUT TPM_DIGEST *Digest
)
{
VOID *Sha1Ctx;
UINTN CtxSize;
CtxSize = Sha1GetContextSize ();
Sha1Ctx = AllocatePool (CtxSize);
ASSERT (Sha1Ctx != NULL);
Sha1Init (Sha1Ctx);
Sha1Update (Sha1Ctx, Data, DataLen);
Sha1Final (Sha1Ctx, (UINT8 *)Digest);
FreePool (Sha1Ctx);
return EFI_SUCCESS;
}

112
SecurityPkg/Tcg/TcgDxe/TpmComm.h
View File

@ -1,112 +0,0 @@
/** @file
Definitions and function prototypes used by TPM DXE driver.
Copyright (c) 2005 - 2016, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef _TPM_COMM_H_
#define _TPM_COMM_H_
/**
Add a new entry to the Event Log.
@param[in, out] EventLogPtr Pointer to the Event Log data.
@param[in, out] LogSize Size of the Event Log.
@param[in] MaxSize Maximum size of the Event Log.
@param[in] NewEventHdr Pointer to a TCG_PCR_EVENT_HDR data structure.
@param[in] NewEventData Pointer to the new event data.
@retval EFI_SUCCESS The new event log entry was added.
@retval EFI_OUT_OF_RESOURCES No enough memory to log the new event.
**/
EFI_STATUS
TpmCommLogEvent (
IN OUT UINT8 **EventLogPtr,
IN OUT UINTN *LogSize,
IN UINTN MaxSize,
IN TCG_PCR_EVENT_HDR *NewEventHdr,
IN UINT8 *NewEventData
);
/**
Extend a TPM PCR.
@param[in] DigestToExtend The 160 bit value representing the event to be recorded.
@param[in] PcrIndex The PCR to be updated.
@param[out] NewPcrValue New PCR value after extend.
@retval EFI_SUCCESS Operation completed successfully.
@retval EFI_DEVICE_ERROR The command was unsuccessful.
**/
EFI_STATUS
TpmCommExtend (
IN TPM_DIGEST *DigestToExtend,
IN TPM_PCRINDEX PcrIndex,
OUT TPM_DIGEST *NewPcrValue
);
/**
Get TPM capability flags.
@param[in] FlagSubcap Flag subcap.
@param[out] FlagBuffer Pointer to the buffer for returned flag structure.
@param[in] FlagSize Size of the buffer.
@retval EFI_SUCCESS Operation completed successfully.
@retval EFI_DEVICE_ERROR The command was unsuccessful.
**/
EFI_STATUS
TpmCommGetFlags (
IN UINT32 FlagSubcap,
OUT VOID *Buffer,
IN UINTN Size
);
/**
Send formatted command to TPM for execution and return formatted data from response.
@param[in] TisReg TPM Handle.
@param[in] Fmt Format control string.
@param[in] ... The variable argument list.
@retval EFI_SUCCESS Operation completed successfully.
@retval EFI_TIMEOUT The register can't run into the expected status in time.
**/
EFI_STATUS
EFIAPI
TisPcExecute (
IN CONST CHAR8 *Fmt,
...
);
/**
Single function calculates SHA1 digest value for all raw data. It
combines Sha1Init(), Sha1Update() and Sha1Final().
@param[in] Data Raw data to be digested.
@param[in] DataLen Size of the raw data.
@param[out] Digest Pointer to a buffer that stores the final digest.
@retval EFI_SUCCESS Always successfully calculate the final digest.
**/
EFI_STATUS
EFIAPI
TpmCommHashAll (
IN CONST UINT8 *Data,
IN UINTN DataLen,
OUT TPM_DIGEST *Digest
);
#endif // _TPM_COMM_H_