CryptHmac.c

Go to the documentation of this file.

 
#include "InternalCryptLib.h"
#include <openssl/hmac.h>
 
STATIC
VOID *
HmacMdNew (
  VOID
  )
{
  //
  // Allocates & Initializes HMAC_CTX Context by OpenSSL HMAC_CTX_new()
  //
  return (VOID *)HMAC_CTX_new ();
}
 
STATIC
VOID
HmacMdFree (
  IN  VOID  *HmacMdCtx
  )
{
  //
  // Free OpenSSL HMAC_CTX Context
  //
  HMAC_CTX_free ((HMAC_CTX *)HmacMdCtx);
}
 
STATIC
BOOLEAN
HmacMdSetKey (
  IN   CONST EVP_MD  *Md,
  OUT  VOID          *HmacMdContext,
  IN   CONST UINT8   *Key,
  IN   UINTN         KeySize
  )
{
  //
  // Check input parameters.
  //
  if ((HmacMdContext == NULL) || (KeySize > INT_MAX)) {
    return FALSE;
  }
 
  if (HMAC_Init_ex ((HMAC_CTX *)HmacMdContext, Key, (UINT32)KeySize, Md, NULL) != 1) {
    return FALSE;
  }
 
  return TRUE;
}
 
STATIC
BOOLEAN
HmacMdDuplicate (
  IN   CONST VOID  *HmacMdContext,
  OUT  VOID        *NewHmacMdContext
  )
{
  //
  // Check input parameters.
  //
  if ((HmacMdContext == NULL) || (NewHmacMdContext == NULL)) {
    return FALSE;
  }
 
  if (HMAC_CTX_copy ((HMAC_CTX *)NewHmacMdContext, (HMAC_CTX *)HmacMdContext) != 1) {
    return FALSE;
  }
 
  return TRUE;
}
 
STATIC
BOOLEAN
HmacMdUpdate (
  IN OUT  VOID        *HmacMdContext,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  //
  // Check input parameters.
  //
  if (HmacMdContext == NULL) {
    return FALSE;
  }
 
  //
  // Check invalid parameters, in case that only DataLength was checked in OpenSSL
  //
  if ((Data == NULL) && (DataSize != 0)) {
    return FALSE;
  }
 
  //
  // OpenSSL HMAC-MD digest update
  //
  if (HMAC_Update ((HMAC_CTX *)HmacMdContext, Data, DataSize) != 1) {
    return FALSE;
  }
 
  return TRUE;
}
 
STATIC
BOOLEAN
HmacMdFinal (
  IN OUT  VOID   *HmacMdContext,
  OUT     UINT8  *HmacValue
  )
{
  UINT32  Length;
 
  //
  // Check input parameters.
  //
  if ((HmacMdContext == NULL) || (HmacValue == NULL)) {
    return FALSE;
  }
 
  //
  // OpenSSL HMAC-MD digest finalization
  //
  if (HMAC_Final ((HMAC_CTX *)HmacMdContext, HmacValue, &Length) != 1) {
    return FALSE;
  }
 
  if (HMAC_CTX_reset ((HMAC_CTX *)HmacMdContext) != 1) {
    return FALSE;
  }
 
  return TRUE;
}
 
STATIC
BOOLEAN
HmacMdAll (
  IN   CONST EVP_MD  *Md,
  IN   CONST VOID    *Data,
  IN   UINTN         DataSize,
  IN   CONST UINT8   *Key,
  IN   UINTN         KeySize,
  OUT  UINT8         *HmacValue
  )
{
  UINT32    Length;
  HMAC_CTX  *Ctx;
  BOOLEAN   RetVal;
 
  Ctx = HMAC_CTX_new ();
  if (Ctx == NULL) {
    return FALSE;
  }
 
  RetVal = (BOOLEAN)HMAC_CTX_reset (Ctx);
  if (!RetVal) {
    goto Done;
  }
 
  RetVal = (BOOLEAN)HMAC_Init_ex (Ctx, Key, (UINT32)KeySize, Md, NULL);
  if (!RetVal) {
    goto Done;
  }
 
  RetVal = (BOOLEAN)HMAC_Update (Ctx, Data, DataSize);
  if (!RetVal) {
    goto Done;
  }
 
  RetVal = (BOOLEAN)HMAC_Final (Ctx, HmacValue, &Length);
  if (!RetVal) {
    goto Done;
  }
 
Done:
  HMAC_CTX_free (Ctx);
 
  return RetVal;
}
 
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 (EVP_sha256 (), HmacSha256Context, Key, KeySize);
}
 
BOOLEAN
EFIAPI
HmacSha256Duplicate (
  IN   CONST VOID  *HmacSha256Context,
  OUT  VOID        *NewHmacSha256Context
  )
{
  return HmacMdDuplicate (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 (EVP_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 (EVP_sha384 (), HmacSha384Context, Key, KeySize);
}
 
BOOLEAN
EFIAPI
HmacSha384Duplicate (
  IN   CONST VOID  *HmacSha384Context,
  OUT  VOID        *NewHmacSha384Context
  )
{
  return HmacMdDuplicate (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 (EVP_sha384 (), Data, DataSize, Key, KeySize, HmacValue);
}