CryptHmac.c

Go to the documentation of this file.

 
#include "InternalCryptLib.h"
#include <mbedtls/md.h>
 
STATIC
VOID *
HmacMdNew (
  VOID
  )
{
  VOID  *HmacMdCtx;
 
  HmacMdCtx = AllocateZeroPool (sizeof (mbedtls_md_context_t));
  if (HmacMdCtx == NULL) {
    return NULL;
  }
 
  return HmacMdCtx;
}
 
VOID
HmacMdFree (
  IN  VOID  *HmacMdCtx
  )
{
  mbedtls_md_free (HmacMdCtx);
  if (HmacMdCtx != NULL) {
    FreePool (HmacMdCtx);
  }
}
 
STATIC
BOOLEAN
HmacMdSetKey (
  IN   mbedtls_md_type_t  MdType,
  OUT  VOID               *HmacMdContext,
  IN   CONST UINT8        *Key,
  IN   UINTN              KeySize
  )
{
  const mbedtls_md_info_t  *md_info;
  INT32                    Ret;
 
  if ((HmacMdContext == NULL) || (KeySize > INT_MAX)) {
    return FALSE;
  }
 
  ZeroMem (HmacMdContext, sizeof (mbedtls_md_context_t));
  mbedtls_md_init (HmacMdContext);
 
  md_info = mbedtls_md_info_from_type (MdType);
  ASSERT (md_info != NULL);
 
  Ret = mbedtls_md_setup (HmacMdContext, md_info, 1);
  if (Ret != 0) {
    return FALSE;
  }
 
  Ret = mbedtls_md_hmac_starts (HmacMdContext, Key, KeySize);
  if (Ret != 0) {
    return FALSE;
  }
 
  return TRUE;
}
 
int
HmacMdGetBlockSize (
  mbedtls_md_type_t  MdType
  )
{
  switch (MdType) {
    case MBEDTLS_MD_SHA256:
      return 64;
    case MBEDTLS_MD_SHA384:
      return 128;
    default:
      ASSERT (FALSE);
      return 0;
  }
}
 
STATIC
BOOLEAN
HmacMdDuplicate (
  IN   CONST mbedtls_md_type_t  MdType,
  IN   CONST VOID               *HmacMdContext,
  OUT  VOID                     *NewHmacMdContext
  )
{
  INT32                    Ret;
  CONST mbedtls_md_info_t  *md_info;
  mbedtls_md_context_t     *MdContext;
 
  if ((HmacMdContext == NULL) || (NewHmacMdContext == NULL)) {
    return FALSE;
  }
 
  ZeroMem (NewHmacMdContext, sizeof (mbedtls_md_context_t));
  mbedtls_md_init (NewHmacMdContext);
  md_info = mbedtls_md_info_from_type (MdType);
  ASSERT (md_info != NULL);
 
  Ret = mbedtls_md_setup (NewHmacMdContext, md_info, 1);
  if (Ret != 0) {
    return FALSE;
  }
 
  MdContext = (mbedtls_md_context_t *)NewHmacMdContext;
 
  Ret = mbedtls_md_clone (NewHmacMdContext, HmacMdContext);
  if (Ret != 0) {
    if (MdContext->md_ctx != NULL) {
      mbedtls_free (MdContext->md_ctx);
    }
 
    if (MdContext->hmac_ctx != NULL) {
      mbedtls_free (MdContext->hmac_ctx);
    }
 
    return FALSE;
  }
 
  CopyMem (
    ((mbedtls_md_context_t *)NewHmacMdContext)->hmac_ctx,
    ((CONST mbedtls_md_context_t *)HmacMdContext)->hmac_ctx,
    HmacMdGetBlockSize (MdType) * 2
    );
 
  return TRUE;
}
 
STATIC
BOOLEAN
HmacMdUpdate (
  IN OUT  VOID        *HmacMdContext,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  INT32  Ret;
 
  if (HmacMdContext == NULL) {
    return FALSE;
  }
 
  if ((Data == NULL) && (DataSize != 0)) {
    return FALSE;
  }
 
  if (DataSize > INT_MAX) {
    return FALSE;
  }
 
  Ret = mbedtls_md_hmac_update (HmacMdContext, Data, DataSize);
  if (Ret != 0) {
    return FALSE;
  }
 
  return TRUE;
}
 
STATIC
BOOLEAN
HmacMdFinal (
  IN OUT  VOID   *HmacMdContext,
  OUT     UINT8  *HmacValue
  )
{
  INT32  Ret;
 
  if ((HmacMdContext == NULL) || (HmacValue == NULL)) {
    return FALSE;
  }
 
  Ret = mbedtls_md_hmac_finish (HmacMdContext, HmacValue);
  if (Ret != 0) {
    return FALSE;
  }
 
  Ret = mbedtls_md_hmac_reset (HmacMdContext);
  if (Ret != 0) {
    return FALSE;
  }
 
  return TRUE;
}
 
STATIC
BOOLEAN
HmacMdAll (
  IN   mbedtls_md_type_t  MdType,
  IN   CONST VOID         *Data,
  IN   UINTN              DataSize,
  IN   CONST UINT8        *Key,
  IN   UINTN              KeySize,
  OUT  UINT8              *HmacValue
  )
{
  const mbedtls_md_info_t  *md_info;
  INT32                    Ret;
 
  md_info = mbedtls_md_info_from_type (MdType);
  ASSERT (md_info != NULL);
 
  Ret = mbedtls_md_hmac (md_info, Key, KeySize, Data, DataSize, HmacValue);
  if (Ret != 0) {
    return FALSE;
  }
 
  return TRUE;
}
 
VOID *
EFIAPI
HmacSha256New (
  VOID
  )
{
  return HmacMdNew ();
}
 
VOID
EFIAPI
HmacSha256Free (
  IN  VOID  *HmacSha256Ctx
  )
{
  HmacMdFree (HmacSha256Ctx);
}
 
BOOLEAN
EFIAPI
HmacSha256SetKey (
  OUT  VOID         *HmacSha256Context,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize
  )
{
  return HmacMdSetKey (MBEDTLS_MD_SHA256, HmacSha256Context, Key, KeySize);
}
 
BOOLEAN
EFIAPI
HmacSha256Duplicate (
  IN   CONST VOID  *HmacSha256Context,
  OUT  VOID        *NewHmacSha256Context
  )
{
  return HmacMdDuplicate (MBEDTLS_MD_SHA256, HmacSha256Context, NewHmacSha256Context);
}
 
BOOLEAN
EFIAPI
HmacSha256Update (
  IN OUT  VOID        *HmacSha256Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return HmacMdUpdate (HmacSha256Context, Data, DataSize);
}
 
BOOLEAN
EFIAPI
HmacSha256Final (
  IN OUT  VOID   *HmacSha256Context,
  OUT     UINT8  *HmacValue
  )
{
  return HmacMdFinal (HmacSha256Context, HmacValue);
}
 
BOOLEAN
EFIAPI
HmacSha256All (
  IN   CONST VOID   *Data,
  IN   UINTN        DataSize,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize,
  OUT  UINT8        *HmacValue
  )
{
  return HmacMdAll (MBEDTLS_MD_SHA256, Data, DataSize, Key, KeySize, HmacValue);
}
 
VOID *
EFIAPI
HmacSha384New (
  VOID
  )
{
  return HmacMdNew ();
}
 
VOID
EFIAPI
HmacSha384Free (
  IN  VOID  *HmacSha384Ctx
  )
{
  HmacMdFree (HmacSha384Ctx);
}
 
BOOLEAN
EFIAPI
HmacSha384SetKey (
  OUT  VOID         *HmacSha384Context,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize
  )
{
  return HmacMdSetKey (MBEDTLS_MD_SHA384, HmacSha384Context, Key, KeySize);
}
 
BOOLEAN
EFIAPI
HmacSha384Duplicate (
  IN   CONST VOID  *HmacSha384Context,
  OUT  VOID        *NewHmacSha384Context
  )
{
  return HmacMdDuplicate (MBEDTLS_MD_SHA384, HmacSha384Context, NewHmacSha384Context);
}
 
BOOLEAN
EFIAPI
HmacSha384Update (
  IN OUT  VOID        *HmacSha384Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return HmacMdUpdate (HmacSha384Context, Data, DataSize);
}
 
BOOLEAN
EFIAPI
HmacSha384Final (
  IN OUT  VOID   *HmacSha384Context,
  OUT     UINT8  *HmacValue
  )
{
  return HmacMdFinal (HmacSha384Context, HmacValue);
}
 
BOOLEAN
EFIAPI
HmacSha384All (
  IN   CONST VOID   *Data,
  IN   UINTN        DataSize,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize,
  OUT  UINT8        *HmacValue
  )
{
  return HmacMdAll (MBEDTLS_MD_SHA384, Data, DataSize, Key, KeySize, HmacValue);
}