Hash2DxeCrypto.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include <Protocol/Hash2.h>
#include <Library/BaseLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseCryptLib.h>
 
#include "Driver.h"
 
typedef
UINTN
(EFIAPI *EFI_HASH_GET_CONTEXT_SIZE)(
  VOID
  );
 
typedef
BOOLEAN
(EFIAPI *EFI_HASH_INIT)(
  OUT  VOID  *HashContext
  );
 
typedef
BOOLEAN
(EFIAPI *EFI_HASH_UPDATE)(
  IN OUT  VOID        *HashContext,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  );
 
typedef
BOOLEAN
(EFIAPI *EFI_HASH_FINAL)(
  IN OUT  VOID   *HashContext,
  OUT     UINT8  *HashValue
  );
 
typedef struct {
  EFI_GUID                     *Guid;
  UINT32                       HashSize;
  EFI_HASH_GET_CONTEXT_SIZE    GetContextSize;
  EFI_HASH_INIT                Init;
  EFI_HASH_UPDATE              Update;
  EFI_HASH_FINAL               Final;
} EFI_HASH_INFO;
 
EFI_HASH_INFO  mHashInfo[] = {
  { &gEfiHashAlgorithmSha256Guid, sizeof (EFI_SHA256_HASH2), Sha256GetContextSize, Sha256Init, Sha256Update, Sha256Final },
  { &gEfiHashAlgorithmSha384Guid, sizeof (EFI_SHA384_HASH2), Sha384GetContextSize, Sha384Init, Sha384Update, Sha384Final },
  { &gEfiHashAlgorithmSha512Guid, sizeof (EFI_SHA512_HASH2), Sha512GetContextSize, Sha512Init, Sha512Update, Sha512Final },
};
 
EFI_STATUS
EFIAPI
BaseCrypto2GetHashSize (
  IN  CONST EFI_HASH2_PROTOCOL  *This,
  IN  CONST EFI_GUID            *HashAlgorithm,
  OUT UINTN                     *HashSize
  );
 
EFI_STATUS
EFIAPI
BaseCrypto2Hash (
  IN CONST EFI_HASH2_PROTOCOL  *This,
  IN CONST EFI_GUID            *HashAlgorithm,
  IN CONST UINT8               *Message,
  IN UINTN                     MessageSize,
  IN OUT EFI_HASH2_OUTPUT      *Hash
  );
 
EFI_STATUS
EFIAPI
BaseCrypto2HashInit (
  IN CONST EFI_HASH2_PROTOCOL  *This,
  IN CONST EFI_GUID            *HashAlgorithm
  );
 
EFI_STATUS
EFIAPI
BaseCrypto2HashUpdate (
  IN CONST EFI_HASH2_PROTOCOL  *This,
  IN CONST UINT8               *Message,
  IN UINTN                     MessageSize
  );
 
EFI_STATUS
EFIAPI
BaseCrypto2HashFinal (
  IN CONST EFI_HASH2_PROTOCOL  *This,
  IN OUT EFI_HASH2_OUTPUT      *Hash
  );
 
EFI_HASH2_PROTOCOL  mHash2Protocol = {
  BaseCrypto2GetHashSize,
  BaseCrypto2Hash,
  BaseCrypto2HashInit,
  BaseCrypto2HashUpdate,
  BaseCrypto2HashFinal,
};
 
EFI_HASH_INFO *
GetHashInfo (
  IN CONST EFI_GUID  *HashAlgorithm
  )
{
  UINTN  Index;
 
  for (Index = 0; Index < sizeof (mHashInfo)/sizeof (mHashInfo[0]); Index++) {
    if (CompareGuid (HashAlgorithm, mHashInfo[Index].Guid)) {
      return &mHashInfo[Index];
    }
  }
 
  return NULL;
}
 
EFI_STATUS
EFIAPI
BaseCrypto2GetHashSize (
  IN  CONST EFI_HASH2_PROTOCOL  *This,
  IN  CONST EFI_GUID            *HashAlgorithm,
  OUT UINTN                     *HashSize
  )
{
  EFI_HASH_INFO  *HashInfo;
 
  if ((This == NULL) || (HashSize == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (HashAlgorithm == NULL) {
    return EFI_UNSUPPORTED;
  }
 
  HashInfo = GetHashInfo (HashAlgorithm);
  if (HashInfo == NULL) {
    return EFI_UNSUPPORTED;
  }
 
  *HashSize = HashInfo->HashSize;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BaseCrypto2Hash (
  IN CONST EFI_HASH2_PROTOCOL  *This,
  IN CONST EFI_GUID            *HashAlgorithm,
  IN CONST UINT8               *Message,
  IN UINTN                     MessageSize,
  IN OUT EFI_HASH2_OUTPUT      *Hash
  )
{
  EFI_HASH_INFO        *HashInfo;
  VOID                 *HashCtx;
  UINTN                CtxSize;
  BOOLEAN              Ret;
  EFI_STATUS           Status;
  HASH2_INSTANCE_DATA  *Instance;
 
  Status = EFI_SUCCESS;
 
  if ((This == NULL) || (Hash == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (HashAlgorithm == NULL) {
    return EFI_UNSUPPORTED;
  }
 
  HashInfo = GetHashInfo (HashAlgorithm);
  if (HashInfo == NULL) {
    return EFI_UNSUPPORTED;
  }
 
  Instance = HASH2_INSTANCE_DATA_FROM_THIS (This);
  if (Instance->HashContext != NULL) {
    FreePool (Instance->HashContext);
  }
 
  Instance->HashInfoContext = NULL;
  Instance->HashContext     = NULL;
 
  //
  // Start hash sequence
  //
  CtxSize = HashInfo->GetContextSize ();
  if (CtxSize == 0) {
    return EFI_UNSUPPORTED;
  }
 
  HashCtx = AllocatePool (CtxSize);
  if (HashCtx == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Ret = HashInfo->Init (HashCtx);
  if (!Ret) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  //
  // Setup the context
  //
  Instance->HashContext     = HashCtx;
  Instance->HashInfoContext = HashInfo;
 
  Ret = HashInfo->Update (HashCtx, Message, MessageSize);
  if (!Ret) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  Ret = HashInfo->Final (HashCtx, (UINT8 *)Hash->Sha1Hash);
  if (!Ret) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
Done:
  //
  // Cleanup the context
  //
  FreePool (HashCtx);
  Instance->HashInfoContext = NULL;
  Instance->HashContext     = NULL;
  return Status;
}
 
EFI_STATUS
EFIAPI
BaseCrypto2HashInit (
  IN CONST EFI_HASH2_PROTOCOL  *This,
  IN CONST EFI_GUID            *HashAlgorithm
  )
{
  EFI_HASH_INFO        *HashInfo;
  VOID                 *HashCtx;
  UINTN                CtxSize;
  BOOLEAN              Ret;
  HASH2_INSTANCE_DATA  *Instance;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (HashAlgorithm == NULL) {
    return EFI_UNSUPPORTED;
  }
 
  HashInfo = GetHashInfo (HashAlgorithm);
  if (HashInfo == NULL) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Consistency Check
  //
  Instance = HASH2_INSTANCE_DATA_FROM_THIS (This);
  if ((Instance->HashContext != NULL) || (Instance->HashInfoContext != NULL)) {
    return EFI_ALREADY_STARTED;
  }
 
  //
  // Start hash sequence
  //
  CtxSize = HashInfo->GetContextSize ();
  if (CtxSize == 0) {
    return EFI_UNSUPPORTED;
  }
 
  HashCtx = AllocatePool (CtxSize);
  if (HashCtx == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Ret = HashInfo->Init (HashCtx);
  if (!Ret) {
    FreePool (HashCtx);
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Setup the context
  //
  Instance->HashContext     = HashCtx;
  Instance->HashInfoContext = HashInfo;
  Instance->Updated         = FALSE;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BaseCrypto2HashUpdate (
  IN CONST EFI_HASH2_PROTOCOL  *This,
  IN CONST UINT8               *Message,
  IN UINTN                     MessageSize
  )
{
  EFI_HASH_INFO        *HashInfo;
  VOID                 *HashCtx;
  BOOLEAN              Ret;
  HASH2_INSTANCE_DATA  *Instance;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Consistency Check
  //
  Instance = HASH2_INSTANCE_DATA_FROM_THIS (This);
  if ((Instance->HashContext == NULL) || (Instance->HashInfoContext == NULL)) {
    return EFI_NOT_READY;
  }
 
  HashInfo = Instance->HashInfoContext;
  HashCtx  = Instance->HashContext;
 
  Ret = HashInfo->Update (HashCtx, Message, MessageSize);
  if (!Ret) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Instance->Updated = TRUE;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BaseCrypto2HashFinal (
  IN CONST EFI_HASH2_PROTOCOL  *This,
  IN OUT EFI_HASH2_OUTPUT      *Hash
  )
{
  EFI_HASH_INFO        *HashInfo;
  VOID                 *HashCtx;
  BOOLEAN              Ret;
  HASH2_INSTANCE_DATA  *Instance;
 
  if ((This == NULL) || (Hash == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Consistency Check
  //
  Instance = HASH2_INSTANCE_DATA_FROM_THIS (This);
  if ((Instance->HashContext == NULL) || (Instance->HashInfoContext == NULL) ||
      (!Instance->Updated))
  {
    return EFI_NOT_READY;
  }
 
  HashInfo = Instance->HashInfoContext;
  HashCtx  = Instance->HashContext;
 
  Ret = HashInfo->Final (HashCtx, (UINT8 *)Hash->Sha1Hash);
 
  //
  // Cleanup the context
  //
  FreePool (HashCtx);
  Instance->HashInfoContext = NULL;
  Instance->HashContext     = NULL;
  Instance->Updated         = FALSE;
 
  if (!Ret) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  return EFI_SUCCESS;
}