TcgStorageCoreLib.h

Go to the documentation of this file.

 
#ifndef _TCG_CORE_H_
#define _TCG_CORE_H_
 
#include <IndustryStandard/TcgStorageCore.h>
 
#define ERROR_CHECK(arg)                                                                  \
  {                                                                                       \
    TCG_RESULT ret = (arg);                                                               \
    if (ret != TcgResultSuccess) {                                                        \
      DEBUG ((DEBUG_INFO, "ERROR_CHECK failed at %a:%u\n", __FILE__, DEBUG_LINE_NUMBER)); \
      return ret;                                                                         \
    }                                                                                     \
  }
 
#define METHOD_STATUS_ERROR_CHECK(arg, failRet)                                                  \
  if ((arg) != TCG_METHOD_STATUS_CODE_SUCCESS) {                                                 \
    DEBUG ((DEBUG_INFO, "Method Status error: 0x%02X (%a)\n", arg, TcgMethodStatusString(arg))); \
    return (failRet);                                                                            \
  }
 
#define NULL_CHECK(arg)                                                                            \
  do {                                                                                             \
    if ((arg) == NULL) {                                                                           \
      DEBUG ((DEBUG_INFO, "NULL_CHECK(%a) failed at %a:%u\n", #arg, __FILE__, DEBUG_LINE_NUMBER)); \
      return TcgResultFailureNullPointer;                                                          \
    }                                                                                              \
  } while (0)
 
#pragma pack(1)
 
typedef enum {
  //
  // This is the return result upon successful completion of a Tcg function call
  //
  TcgResultSuccess,
 
  //
  // This is the return "catchall" result for the failure of a Tcg function call
  //
  TcgResultFailure,
 
  //
  // This is the return result if a required parameter was Null for a Tcg function call
  //
  TcgResultFailureNullPointer,
 
  //
  // This is the return result if a required buffersize was 0 for a Tcg function call
  //
  TcgResultFailureZeroSize,
 
  //
  // This is the return result if a Tcg function call was executed out of order.
  // For instance, starting a Tcg subpacket before starting its Tcg packet.
  //
  TcgResultFailureInvalidAction,
 
  //
  // This is the return result if the buffersize provided is not big enough to add a requested Tcg encoded item.
  //
  TcgResultFailureBufferTooSmall,
 
  //
  // This is the return result for a Tcg parse function if the end of the parsed Buffer is reached, yet Data is still attempted to be retrieved.
  // For instance, attempting to retrieve another Tcg token from the Buffer after it has reached the end of the Tcg subpacket payload.
  //
  TcgResultFailureEndBuffer,
 
  //
  // This is the return result for a Tcg parse function if the Tcg Token item requested is not the expected type.
  // For instance, the caller requested to receive an integer and the Tcg token was a byte sequence.
  //
  TcgResultFailureInvalidType,
} TCG_RESULT;
 
//
// Structure that is used to build the Tcg ComPacket.  It contains the start Buffer pointer and the current position of the
// Tcg ComPacket, current Tcg Packet and Tcg SubPacket. This structure must be initialized
// by calling tcgInitTcgCreateStruct before it is used as parameter to any other Tcg function.
// This structure should NOT be directly modified by the client of this library.
//
//  NOTE:  WE MAY MAKE THIS AN ABSTRACT STRUCTURE WITH A DEFINED SIZE AND KEEP THE VARIABLES
//         INTERNAL AND ONLY KNOWN TO THE TCG LIBRARY
//
// tcgInitTcgCreateStruct
//
typedef struct {
  //
  // Buffer allocated and freed by the client of the Tcg library.
  // This is the Buffer that shall contain the final Tcg encoded compacket.
  //
  VOID              *Buffer;
 
  //
  // Size of the Buffer provided.
  //
  UINT32            BufferSize;
 
  //
  // Pointer to the start of the Tcg ComPacket.  It should point to a location within Buffer.
  //
  TCG_COM_PACKET    *ComPacket;
 
  //
  // Current Tcg Packet that is being created.  It should point to a location within Buffer.
  //
  TCG_PACKET        *CurPacket;
 
  //
  // Current Tcg SubPacket that is being created.  It should point to a location within Buffer.
  //
  TCG_SUB_PACKET    *CurSubPacket;
 
  //
  // Flag used to indicate if the Buffer of the structure should be filled out.
  // This is intended to be used to support a use-case where the client of library
  // can perform all the desired tcg calls to determine what the actual Size of the final compacket will be.
  // Then the client can allocate the required Buffer Size and re-run the tcg calls.
  // THIS MAY NOT BE IMPLEMENTED... REQUIRES MORE THOUGHT BECAUSE YOU CANNOT SOLVE ISSUE FOR RECEIVE
  //
  BOOLEAN    DryRun;
} TCG_CREATE_STRUCT;
 
//
// Structure that is used to parse the Tcg response received.  It contains the response Buffer pointer
// and the current position of the Tcg ComPacket, current Tcg Packet and Tcg SubPacket being parsed.
// This structure must be initialized by calling tcgInitTcgParseStruct before it is used as parameter to any other Tcg parse function.
// This structure should NOT be directly modified by the client of this library.
//
//  NOTE:  WE MAY MAKE THIS AN ABSTRACT STRUCTURE WITH A DEFINED SIZE AND KEEP THE VARIABLES
//         INTERNAL AND ONLY KNOWN TO THE TCG LIBRARY
//
// @sa tcgInitTcgParseStruct
//
typedef struct  {
  //
  // Buffer allocated and freed by the client of the Tcg library.
  // This is the Buffer that contains the Tcg response to decode/parse.
  //
  const VOID        *Buffer;
 
  //
  // Size of the Buffer provided.
  //
  UINT32            BufferSize;
 
  //
  // Pointer to the start of the Tcg ComPacket.  It should point to a location within Buffer.
  //
  TCG_COM_PACKET    *ComPacket;
 
  //
  // Current Tcg Packet that is being created.  It should point to a location within Buffer.
  //
  TCG_PACKET        *CurPacket;
 
  //
  // Current Tcg SubPacket that is being created.  It should point to a location within Buffer.
  //
  TCG_SUB_PACKET    *CurSubPacket;
 
  //
  // Current pointer within the current subpacket payload.
  //
  UINT8             *CurPtr;
} TCG_PARSE_STRUCT;
 
//
// Structure that is used to represent a Tcg Token that is retrieved by Tcg parse functions.
//
typedef struct {
  //
  // Describes the type of Tcg token the Hdr start points to.
  //
  TCG_TOKEN_TYPE    Type;
 
  //
  // Pointer to the beginning of the Header of the Tcg token
  //
  UINT8             *HdrStart;
} TCG_TOKEN;
 
TCG_RESULT
EFIAPI
TcgInitTcgCreateStruct (
  TCG_CREATE_STRUCT  *CreateStruct,
  VOID               *Buffer,
  UINT32             BufferSize
  );
 
TCG_RESULT
EFIAPI
TcgStartComPacket (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT16             ComId,
  UINT16             ComIdExtension
  );
 
TCG_RESULT
EFIAPI
TcgStartPacket (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             Tsn,
  UINT32             Hsn,
  UINT32             SeqNumber,
  UINT16             AckType,
  UINT32             Ack
  );
 
TCG_RESULT
EFIAPI
TcgStartSubPacket (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT16             Kind
  );
 
TCG_RESULT
EFIAPI
TcgEndSubPacket (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgEndPacket (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgEndComPacket (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             *Size
  );
 
TCG_RESULT
EFIAPI
TcgAddRawByte (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT8              Byte
  );
 
TCG_RESULT
EFIAPI
TcgAddByteSequence (
  TCG_CREATE_STRUCT  *CreateStruct,
  const VOID         *Data,
  UINT32             DataSize,
  BOOLEAN            Continued
  );
 
TCG_RESULT
EFIAPI
TcgAddInteger (
  TCG_CREATE_STRUCT  *CreateStruct,
  const VOID         *Data,
  UINT32             DataSize,
  BOOLEAN            SignedInteger
  );
 
TCG_RESULT
EFIAPI
TcgAddUINT8 (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT8              Value
  );
 
TCG_RESULT
EFIAPI
TcgAddUINT16 (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT16             Value
  );
 
TCG_RESULT
EFIAPI
TcgAddUINT32 (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             Value
  );
 
TCG_RESULT
EFIAPI
TcgAddUINT64 (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT64             Value
  );
 
TCG_RESULT
EFIAPI
TcgAddBOOLEAN (
  TCG_CREATE_STRUCT  *CreateStruct,
  BOOLEAN            Value
  );
 
TCG_RESULT
EFIAPI
TcgAddTcgUid (
  TCG_CREATE_STRUCT  *CreateStruct,
  TCG_UID            Uid
  );
 
TCG_RESULT
EFIAPI
TcgAddStartList (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgAddEndList (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgAddStartName (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgAddEndName (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgAddCall (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgAddEndOfData (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgAddEndOfSession (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgAddStartTransaction (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgAddEndTransaction (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgInitTcgParseStruct (
  TCG_PARSE_STRUCT  *ParseStruct,
  const VOID        *Buffer,
  UINT32            BufferSize
  );
 
TCG_RESULT
EFIAPI
TcgGetNextToken (
  TCG_PARSE_STRUCT  *ParseStruct,
  TCG_TOKEN         *TcgToken
  );
 
TCG_RESULT
EFIAPI
TcgGetNextTokenType (
  TCG_PARSE_STRUCT  *ParseStruct,
  TCG_TOKEN_TYPE    Type
  );
 
TCG_RESULT
EFIAPI
TcgGetAtomInfo (
  const TCG_TOKEN  *TcgToken,
  UINT32           *HeaderLength,
  UINT32           *DataLength,
  UINT8            *ByteOrInt,
  UINT8            *SignOrCont
  );
 
UINT8 *
EFIAPI
TcgGetTokenByteSequence (
  const TCG_TOKEN  *TcgToken,
  UINT32           *Length
  );
 
TCG_RESULT
EFIAPI
TcgGetTokenUINT64 (
  const TCG_TOKEN  *TcgToken,
  UINT64           *Value
  );
 
TCG_RESULT
EFIAPI
TcgGetNextUINT8 (
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT8             *Value
  );
 
TCG_RESULT
EFIAPI
TcgGetNextUINT16 (
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT16            *Value
  );
 
TCG_RESULT
EFIAPI
TcgGetNextUINT32 (
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT32            *Value
  );
 
TCG_RESULT
EFIAPI
TcgGetNextUINT64 (
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT64            *Value
  );
 
TCG_RESULT
EFIAPI
TcgGetNextBOOLEAN (
  TCG_PARSE_STRUCT  *ParseStruct,
  BOOLEAN           *Value
  );
 
TCG_RESULT
EFIAPI
TcgGetNextTcgUid (
  TCG_PARSE_STRUCT  *ParseStruct,
  TCG_UID           *Uid
  );
 
TCG_RESULT
EFIAPI
TcgGetNextByteSequence (
  TCG_PARSE_STRUCT  *ParseStruct,
  const VOID        **Data,
  UINT32            *Length
  );
 
TCG_RESULT
EFIAPI
TcgGetNextStartList (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
TCG_RESULT
EFIAPI
TcgGetNextEndList (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
TCG_RESULT
EFIAPI
TcgGetNextStartName (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
TCG_RESULT
EFIAPI
TcgGetNextEndName (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
TCG_RESULT
EFIAPI
TcgGetNextCall (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
TCG_RESULT
EFIAPI
TcgGetNextEndOfData (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
TCG_RESULT
EFIAPI
TcgGetNextEndOfSession (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
TCG_RESULT
EFIAPI
TcgGetNextStartTransaction (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
TCG_RESULT
EFIAPI
TcgGetNextEndTransaction (
  TCG_PARSE_STRUCT  *ParseStruct
  );
 
// end of parse functions
 
typedef
BOOLEAN
(EFIAPI *TCG_LEVEL0_ENUM_CALLBACK)(
  const TCG_LEVEL0_DISCOVERY_HEADER      *DiscoveryHeader,
  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER   *Feature,
  UINTN                                  FeatureSize, // includes header
  VOID                                   *Context
  );
 
TCG_RESULT
EFIAPI
TcgStartMethodCall (
  TCG_CREATE_STRUCT  *CreateStruct,
  TCG_UID            InvokingId,
  TCG_UID            MethodId
  );
 
TCG_RESULT
EFIAPI
TcgStartParameters (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgEndParameters (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgEndMethodCall (
  TCG_CREATE_STRUCT  *CreateStruct
  );
 
TCG_RESULT
EFIAPI
TcgCreateStartSession (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             *Size,
  UINT16             ComId,
  UINT16             ComIdExtension,
  UINT32             HostSessionId,
  TCG_UID            SpId,
  BOOLEAN            Write,
  UINT32             HostChallengeLength,
  const VOID         *HostChallenge,
  TCG_UID            HostSigningAuthority
  );
 
TCG_RESULT
EFIAPI
TcgCreateSetCPin (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             *Size,
  UINT16             ComId,
  UINT16             ComIdExtension,
  UINT32             TperSession,
  UINT32             HostSession,
  TCG_UID            SidRow,
  const VOID         *Password,
  UINT32             PasswordSize
  );
 
TCG_RESULT
EFIAPI
TcgSetAuthorityEnabled (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             *Size,
  UINT16             ComId,
  UINT16             ComIdExtension,
  UINT32             TperSession,
  UINT32             HostSession,
  TCG_UID            AuthorityUid,
  BOOLEAN            Enabled
  );
 
TCG_RESULT
EFIAPI
TcgCreateEndSession (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             *Size,
  UINT16             ComId,
  UINT16             ComIdExtension,
  UINT32             HostSessionId,
  UINT32             TpSessionId
  );
 
CHAR8 *
EFIAPI
TcgTokenTypeString (
  TCG_TOKEN_TYPE  Type
  );
 
TCG_RESULT
EFIAPI
TcgGetMethodStatus (
  const TCG_PARSE_STRUCT  *ParseStruct,
  UINT8                   *MethodStatus
  );
 
CHAR8 *
EFIAPI
TcgMethodStatusString (
  UINT8  MethodStatus
  );
 
TCG_RESULT
EFIAPI
TcgGetComIds (
  const TCG_PARSE_STRUCT  *ParseStruct,
  UINT16                  *ComId,
  UINT16                  *ComIdExtension
  );
 
TCG_RESULT
EFIAPI
TcgCheckComIds (
  const TCG_PARSE_STRUCT  *ParseStruct,
  UINT16                  ExpectedComId,
  UINT16                  ExpectedComIdExtension
  );
 
TCG_RESULT
EFIAPI
TcgParseSyncSession (
  const TCG_PARSE_STRUCT  *ParseStruct,
  UINT16                  ComId,
  UINT16                  ComIdExtension,
  UINT32                  HostSessionId,
  UINT32                  *TperSessionId
  );
 
TCG_RESULT
EFIAPI
TcgCreateSetAce (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             *Size,
  UINT16             ComId,
  UINT16             ComIdExtension,
  UINT32             TperSession,
  UINT32             HostSession,
  TCG_UID            AceRow,
  TCG_UID            Authority1,
  BOOLEAN            LogicalOperator,
  TCG_UID            Authority2
  );
 
BOOLEAN
EFIAPI
TcgEnumLevel0Discovery (
  const TCG_LEVEL0_DISCOVERY_HEADER  *DiscoveryHeader,
  TCG_LEVEL0_ENUM_CALLBACK           Callback,
  VOID                               *Context
  );
 
TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER *
EFIAPI
TcgGetFeature (
  const TCG_LEVEL0_DISCOVERY_HEADER  *DiscoveryHeader,
  UINT16                             FeatureCode,
  UINTN                              *FeatureSize
  );
 
BOOLEAN
EFIAPI
TcgIsProtocolSupported (
  const TCG_SUPPORTED_SECURITY_PROTOCOLS  *ProtocolList,
  UINT16                                  Protocol
  );
 
BOOLEAN
EFIAPI
TcgIsLocked (
  const TCG_LEVEL0_DISCOVERY_HEADER  *Discovery
  );
 
#pragma pack()
 
#endif // _TCG_CORE_H_