SecurityPkg: Apply uncrustify changes

[mirror_edk2.git] / SecurityPkg / Library / Tpm2CommandLib / Tpm2Sequences.c

/** @file\r
  Implement TPM2 Sequences related command.\r
\r
Copyright (c) 2013 - 2018, Intel Corporation. All rights reserved. <BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <IndustryStandard/UefiTcgPlatform.h>\r
#include <Library/Tpm2CommandLib.h>\r
#include <Library/Tpm2DeviceLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
\r
#pragma pack(1)\r
\r
typedef struct {\r
  TPM2_COMMAND_HEADER    Header;\r
  TPM2B_AUTH             Auth;\r
  TPMI_ALG_HASH          HashAlg;\r
} TPM2_HASH_SEQUENCE_START_COMMAND;\r
\r
typedef struct {\r
  TPM2_RESPONSE_HEADER    Header;\r
  TPMI_DH_OBJECT          SequenceHandle;\r
} TPM2_HASH_SEQUENCE_START_RESPONSE;\r
\r
typedef struct {\r
  TPM2_COMMAND_HEADER    Header;\r
  TPMI_DH_OBJECT         SequenceHandle;\r
  UINT32                 AuthorizationSize;\r
  TPMS_AUTH_COMMAND      AuthSessionSeq;\r
  TPM2B_MAX_BUFFER       Buffer;\r
} TPM2_SEQUENCE_UPDATE_COMMAND;\r
\r
typedef struct {\r
  TPM2_RESPONSE_HEADER    Header;\r
  UINT32                  ParameterSize;\r
  TPMS_AUTH_RESPONSE      AuthSessionSeq;\r
} TPM2_SEQUENCE_UPDATE_RESPONSE;\r
\r
typedef struct {\r
  TPM2_COMMAND_HEADER    Header;\r
  TPMI_DH_PCR            PcrHandle;\r
  TPMI_DH_OBJECT         SequenceHandle;\r
  UINT32                 AuthorizationSize;\r
  TPMS_AUTH_COMMAND      AuthSessionPcr;\r
  TPMS_AUTH_COMMAND      AuthSessionSeq;\r
  TPM2B_MAX_BUFFER       Buffer;\r
} TPM2_EVENT_SEQUENCE_COMPLETE_COMMAND;\r
\r
typedef struct {\r
  TPM2_RESPONSE_HEADER    Header;\r
  UINT32                  ParameterSize;\r
  TPML_DIGEST_VALUES      Results;\r
  TPMS_AUTH_RESPONSE      AuthSessionPcr;\r
  TPMS_AUTH_RESPONSE      AuthSessionSeq;\r
} TPM2_EVENT_SEQUENCE_COMPLETE_RESPONSE;\r
\r
typedef struct {\r
  TPM2_COMMAND_HEADER    Header;\r
  TPMI_DH_OBJECT         SequenceHandle;\r
  UINT32                 AuthorizationSize;\r
  TPMS_AUTH_COMMAND      AuthSessionSeq;\r
  TPM2B_MAX_BUFFER       Buffer;\r
  TPMI_RH_HIERARCHY      Hierarchy;\r
} TPM2_SEQUENCE_COMPLETE_COMMAND;\r
\r
typedef struct {\r
  TPM2_RESPONSE_HEADER    Header;\r
  UINT32                  ParameterSize;\r
  TPM2B_DIGEST            Digest;\r
  TPMS_AUTH_RESPONSE      AuthSessionSeq;\r
} TPM2_SEQUENCE_COMPLETE_RESPONSE;\r
\r
#pragma pack()\r
\r
/**\r
  This command starts a hash or an Event sequence.\r
  If hashAlg is an implemented hash, then a hash sequence is started.\r
  If hashAlg is TPM_ALG_NULL, then an Event sequence is started.\r
\r
  @param[in]  HashAlg           The hash algorithm to use for the hash sequence\r
                                An Event sequence starts if this is TPM_ALG_NULL.\r
  @param[out] SequenceHandle    A handle to reference the sequence\r
\r
  @retval EFI_SUCCESS      Operation completed successfully.\r
  @retval EFI_DEVICE_ERROR Unexpected device behavior.\r
**/\r
EFI_STATUS\r
EFIAPI\r
Tpm2HashSequenceStart (\r
  IN TPMI_ALG_HASH    HashAlg,\r
  OUT TPMI_DH_OBJECT  *SequenceHandle\r
  )\r
{\r
  EFI_STATUS                         Status;\r
  TPM2_HASH_SEQUENCE_START_COMMAND   Cmd;\r
  TPM2_HASH_SEQUENCE_START_RESPONSE  Res;\r
  UINT32                             CmdSize;\r
  UINT32                             RespSize;\r
  UINT8                              *Buffer;\r
  UINT32                             ResultBufSize;\r
\r
  ZeroMem (&Cmd, sizeof (Cmd));\r
\r
  //\r
  // Construct command\r
  //\r
  Cmd.Header.tag         = SwapBytes16 (TPM_ST_NO_SESSIONS);\r
  Cmd.Header.commandCode = SwapBytes32 (TPM_CC_HashSequenceStart);\r
\r
  Buffer = (UINT8 *)&Cmd.Auth;\r
\r
  // auth = nullAuth\r
  WriteUnaligned16 ((UINT16 *)Buffer, SwapBytes16 (0));\r
  Buffer += sizeof (UINT16);\r
\r
  // hashAlg\r
  WriteUnaligned16 ((UINT16 *)Buffer, SwapBytes16 (HashAlg));\r
  Buffer += sizeof (UINT16);\r
\r
  CmdSize              = (UINT32)(Buffer - (UINT8 *)&Cmd);\r
  Cmd.Header.paramSize = SwapBytes32 (CmdSize);\r
\r
  //\r
  // Call the TPM\r
  //\r
  ResultBufSize = sizeof (Res);\r
  Status        = Tpm2SubmitCommand (CmdSize, (UINT8 *)&Cmd, &ResultBufSize, (UINT8 *)&Res);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (ResultBufSize > sizeof (Res)) {\r
    DEBUG ((DEBUG_ERROR, "HashSequenceStart: Failed ExecuteCommand: Buffer Too Small\r\n"));\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Validate response headers\r
  //\r
  RespSize = SwapBytes32 (Res.Header.paramSize);\r
  if (RespSize > sizeof (Res)) {\r
    DEBUG ((DEBUG_ERROR, "HashSequenceStart: Response size too large! %d\r\n", RespSize));\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Fail if command failed\r
  //\r
  if (SwapBytes32 (Res.Header.responseCode) != TPM_RC_SUCCESS) {\r
    DEBUG ((DEBUG_ERROR, "HashSequenceStart: Response Code error! 0x%08x\r\n", SwapBytes32 (Res.Header.responseCode)));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // Unmarshal the response\r
  //\r
\r
  // sequenceHandle\r
  *SequenceHandle = SwapBytes32 (Res.SequenceHandle);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This command is used to add data to a hash or HMAC sequence.\r
  The amount of data in buffer may be any size up to the limits of the TPM.\r
  NOTE: In all TPM, a buffer size of 1,024 octets is allowed.\r
\r
  @param[in] SequenceHandle    Handle for the sequence object\r
  @param[in] Buffer            Data to be added to hash\r
\r
  @retval EFI_SUCCESS      Operation completed successfully.\r
  @retval EFI_DEVICE_ERROR Unexpected device behavior.\r
**/\r
EFI_STATUS\r
EFIAPI\r
Tpm2SequenceUpdate (\r
  IN TPMI_DH_OBJECT    SequenceHandle,\r
  IN TPM2B_MAX_BUFFER  *Buffer\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  TPM2_SEQUENCE_UPDATE_COMMAND   Cmd;\r
  TPM2_SEQUENCE_UPDATE_RESPONSE  Res;\r
  UINT32                         CmdSize;\r
  UINT32                         RespSize;\r
  UINT8                          *BufferPtr;\r
  UINT32                         SessionInfoSize;\r
  UINT32                         ResultBufSize;\r
\r
  ZeroMem (&Cmd, sizeof (Cmd));\r
\r
  //\r
  // Construct command\r
  //\r
  Cmd.Header.tag         = SwapBytes16 (TPM_ST_SESSIONS);\r
  Cmd.Header.commandCode = SwapBytes32 (TPM_CC_SequenceUpdate);\r
  Cmd.SequenceHandle     = SwapBytes32 (SequenceHandle);\r
\r
  //\r
  // Add in Auth session\r
  //\r
  BufferPtr = (UINT8 *)&Cmd.AuthSessionSeq;\r
\r
  // sessionInfoSize\r
  SessionInfoSize       = CopyAuthSessionCommand (NULL, BufferPtr);\r
  BufferPtr            += SessionInfoSize;\r
  Cmd.AuthorizationSize = SwapBytes32 (SessionInfoSize);\r
\r
  // buffer.size\r
  WriteUnaligned16 ((UINT16 *)BufferPtr, SwapBytes16 (Buffer->size));\r
  BufferPtr += sizeof (UINT16);\r
\r
  CopyMem (BufferPtr, &Buffer->buffer, Buffer->size);\r
  BufferPtr += Buffer->size;\r
\r
  CmdSize              = (UINT32)(BufferPtr - (UINT8 *)&Cmd);\r
  Cmd.Header.paramSize = SwapBytes32 (CmdSize);\r
\r
  //\r
  // Call the TPM\r
  //\r
  ResultBufSize = sizeof (Res);\r
  Status        = Tpm2SubmitCommand (CmdSize, (UINT8 *)&Cmd, &ResultBufSize, (UINT8 *)&Res);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (ResultBufSize > sizeof (Res)) {\r
    DEBUG ((DEBUG_ERROR, "SequenceUpdate: Failed ExecuteCommand: Buffer Too Small\r\n"));\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Validate response headers\r
  //\r
  RespSize = SwapBytes32 (Res.Header.paramSize);\r
  if (RespSize > sizeof (Res)) {\r
    DEBUG ((DEBUG_ERROR, "SequenceUpdate: Response size too large! %d\r\n", RespSize));\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Fail if command failed\r
  //\r
  if (SwapBytes32 (Res.Header.responseCode) != TPM_RC_SUCCESS) {\r
    DEBUG ((DEBUG_ERROR, "SequenceUpdate: Response Code error! 0x%08x\r\n", SwapBytes32 (Res.Header.responseCode)));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // Unmarshal the response\r
  //\r
\r
  // None\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This command adds the last part of data, if any, to an Event sequence and returns the result in a digest list.\r
  If pcrHandle references a PCR and not TPM_RH_NULL, then the returned digest list is processed in\r
  the same manner as the digest list input parameter to TPM2_PCR_Extend() with the pcrHandle in each\r
  bank extended with the associated digest value.\r
\r
  @param[in]  PcrHandle         PCR to be extended with the Event data\r
  @param[in]  SequenceHandle    Authorization for the sequence\r
  @param[in]  Buffer            Data to be added to the Event\r
  @param[out] Results           List of digests computed for the PCR\r
\r
  @retval EFI_SUCCESS      Operation completed successfully.\r
  @retval EFI_DEVICE_ERROR Unexpected device behavior.\r
**/\r
EFI_STATUS\r
EFIAPI\r
Tpm2EventSequenceComplete (\r
  IN TPMI_DH_PCR          PcrHandle,\r
  IN TPMI_DH_OBJECT       SequenceHandle,\r
  IN TPM2B_MAX_BUFFER     *Buffer,\r
  OUT TPML_DIGEST_VALUES  *Results\r
  )\r
{\r
  EFI_STATUS                             Status;\r
  TPM2_EVENT_SEQUENCE_COMPLETE_COMMAND   Cmd;\r
  TPM2_EVENT_SEQUENCE_COMPLETE_RESPONSE  Res;\r
  UINT32                                 CmdSize;\r
  UINT32                                 RespSize;\r
  UINT8                                  *BufferPtr;\r
  UINT32                                 SessionInfoSize;\r
  UINT32                                 SessionInfoSize2;\r
  UINT32                                 Index;\r
  UINT32                                 ResultBufSize;\r
  UINT16                                 DigestSize;\r
\r
  ZeroMem (&Cmd, sizeof (Cmd));\r
\r
  //\r
  // Construct command\r
  //\r
  Cmd.Header.tag         = SwapBytes16 (TPM_ST_SESSIONS);\r
  Cmd.Header.commandCode = SwapBytes32 (TPM_CC_EventSequenceComplete);\r
  Cmd.PcrHandle          = SwapBytes32 (PcrHandle);\r
  Cmd.SequenceHandle     = SwapBytes32 (SequenceHandle);\r
\r
  //\r
  // Add in pcrHandle Auth session\r
  //\r
  BufferPtr = (UINT8 *)&Cmd.AuthSessionPcr;\r
\r
  // sessionInfoSize\r
  SessionInfoSize = CopyAuthSessionCommand (NULL, BufferPtr);\r
  BufferPtr      += SessionInfoSize;\r
\r
  // sessionInfoSize\r
  SessionInfoSize2      = CopyAuthSessionCommand (NULL, BufferPtr);\r
  BufferPtr            += SessionInfoSize2;\r
  Cmd.AuthorizationSize = SwapBytes32 (SessionInfoSize + SessionInfoSize2);\r
\r
  // buffer.size\r
  WriteUnaligned16 ((UINT16 *)BufferPtr, SwapBytes16 (Buffer->size));\r
  BufferPtr += sizeof (UINT16);\r
\r
  CopyMem (BufferPtr, &Buffer->buffer[0], Buffer->size);\r
  BufferPtr += Buffer->size;\r
\r
  CmdSize              = (UINT32)(BufferPtr - (UINT8 *)&Cmd);\r
  Cmd.Header.paramSize = SwapBytes32 (CmdSize);\r
\r
  //\r
  // Call the TPM\r
  //\r
  ResultBufSize = sizeof (Res);\r
  Status        = Tpm2SubmitCommand (CmdSize, (UINT8 *)&Cmd, &ResultBufSize, (UINT8 *)&Res);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (ResultBufSize > sizeof (Res)) {\r
    DEBUG ((DEBUG_ERROR, "EventSequenceComplete: Failed ExecuteCommand: Buffer Too Small\r\n"));\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Validate response headers\r
  //\r
  RespSize = SwapBytes32 (Res.Header.paramSize);\r
  if (RespSize > sizeof (Res)) {\r
    DEBUG ((DEBUG_ERROR, "EventSequenceComplete: Response size too large! %d\r\n", RespSize));\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Fail if command failed\r
  //\r
  if (SwapBytes32 (Res.Header.responseCode) != TPM_RC_SUCCESS) {\r
    DEBUG ((DEBUG_ERROR, "EventSequenceComplete: Response Code error! 0x%08x\r\n", SwapBytes32 (Res.Header.responseCode)));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // Unmarshal the response\r
  //\r
\r
  BufferPtr = (UINT8 *)&Res.Results;\r
\r
  // count\r
  Results->count = SwapBytes32 (ReadUnaligned32 ((UINT32 *)BufferPtr));\r
  if (Results->count > HASH_COUNT) {\r
    DEBUG ((DEBUG_ERROR, "Tpm2EventSequenceComplete - Results->count error %x\n", Results->count));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  BufferPtr += sizeof (UINT32);\r
\r
  for (Index = 0; Index < Results->count; Index++) {\r
    Results->digests[Index].hashAlg = SwapBytes16 (ReadUnaligned16 ((UINT16 *)BufferPtr));\r
    BufferPtr                      += sizeof (UINT16);\r
\r
    DigestSize = GetHashSizeFromAlgo (Results->digests[Index].hashAlg);\r
    if (DigestSize == 0) {\r
      DEBUG ((DEBUG_ERROR, "EventSequenceComplete: Unknown hash algorithm %d\r\n", Results->digests[Index].hashAlg));\r
      return EFI_DEVICE_ERROR;\r
    }\r
\r
    CopyMem (\r
      &Results->digests[Index].digest,\r
      BufferPtr,\r
      DigestSize\r
      );\r
    BufferPtr += DigestSize;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This command adds the last part of data, if any, to a hash/HMAC sequence and returns the result.\r
\r
  @param[in]  SequenceHandle    Authorization for the sequence\r
  @param[in]  Buffer            Data to be added to the hash/HMAC\r
  @param[out] Result            The returned HMAC or digest in a sized buffer\r
\r
  @retval EFI_SUCCESS      Operation completed successfully.\r
  @retval EFI_DEVICE_ERROR Unexpected device behavior.\r
**/\r
EFI_STATUS\r
EFIAPI\r
Tpm2SequenceComplete (\r
  IN TPMI_DH_OBJECT    SequenceHandle,\r
  IN TPM2B_MAX_BUFFER  *Buffer,\r
  OUT TPM2B_DIGEST     *Result\r
  )\r
{\r
  EFI_STATUS                       Status;\r
  TPM2_SEQUENCE_COMPLETE_COMMAND   Cmd;\r
  TPM2_SEQUENCE_COMPLETE_RESPONSE  Res;\r
  UINT32                           CmdSize;\r
  UINT32                           RespSize;\r
  UINT8                            *BufferPtr;\r
  UINT32                           SessionInfoSize;\r
  UINT32                           ResultBufSize;\r
\r
  ZeroMem (&Cmd, sizeof (Cmd));\r
\r
  //\r
  // Construct command\r
  //\r
  Cmd.Header.tag         = SwapBytes16 (TPM_ST_SESSIONS);\r
  Cmd.Header.commandCode = SwapBytes32 (TPM_CC_SequenceComplete);\r
  Cmd.SequenceHandle     = SwapBytes32 (SequenceHandle);\r
\r
  //\r
  // Add in Auth session\r
  //\r
  BufferPtr = (UINT8 *)&Cmd.AuthSessionSeq;\r
\r
  // sessionInfoSize\r
  SessionInfoSize       = CopyAuthSessionCommand (NULL, BufferPtr);\r
  BufferPtr            += SessionInfoSize;\r
  Cmd.AuthorizationSize = SwapBytes32 (SessionInfoSize);\r
\r
  // buffer.size\r
  WriteUnaligned16 ((UINT16 *)BufferPtr, SwapBytes16 (Buffer->size));\r
  BufferPtr += sizeof (UINT16);\r
\r
  CopyMem (BufferPtr, &Buffer->buffer[0], Buffer->size);\r
  BufferPtr += Buffer->size;\r
\r
  // Hierarchy\r
  WriteUnaligned32 ((UINT32 *)BufferPtr, SwapBytes32 (TPM_RH_NULL));\r
  BufferPtr += sizeof (UINT32);\r
\r
  CmdSize              = (UINT32)(BufferPtr - (UINT8 *)&Cmd);\r
  Cmd.Header.paramSize = SwapBytes32 (CmdSize);\r
\r
  //\r
  // Call the TPM\r
  //\r
  ResultBufSize = sizeof (Res);\r
  Status        = Tpm2SubmitCommand (CmdSize, (UINT8 *)&Cmd, &ResultBufSize, (UINT8 *)&Res);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (ResultBufSize > sizeof (Res)) {\r
    DEBUG ((DEBUG_ERROR, "SequenceComplete: Failed ExecuteCommand: Buffer Too Small\r\n"));\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Validate response headers\r
  //\r
  RespSize = SwapBytes32 (Res.Header.paramSize);\r
  if (RespSize > sizeof (Res)) {\r
    DEBUG ((DEBUG_ERROR, "SequenceComplete: Response size too large! %d\r\n", RespSize));\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Fail if command failed\r
  //\r
  if (SwapBytes32 (Res.Header.responseCode) != TPM_RC_SUCCESS) {\r
    DEBUG ((DEBUG_ERROR, "SequenceComplete: Response Code error! 0x%08x\r\n", SwapBytes32 (Res.Header.responseCode)));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // Unmarshal the response\r
  //\r
\r
  BufferPtr = (UINT8 *)&Res.Digest;\r
\r
  // digestSize\r
  Result->size = SwapBytes16 (ReadUnaligned16 ((UINT16 *)BufferPtr));\r
  if (Result->size > sizeof (TPMU_HA)) {\r
    DEBUG ((DEBUG_ERROR, "Tpm2SequenceComplete - Result->size error %x\n", Result->size));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  BufferPtr += sizeof (UINT16);\r
\r
  CopyMem (\r
    Result->buffer,\r
    BufferPtr,\r
    Result->size\r
    );\r
\r
  return EFI_SUCCESS;\r
}\r