hmacimpl.c

来自「IBE是一种非对称密码技术」· C语言 代码 · 共 188 行

/* Copyright 2003-2006, Voltage Security, all rights reserved.
 */
#include "environment.h"
#include "base.h"
#include "libctx.h"
#include "algobj.h"
#include "digest.h"
#include "voltmac.h"
#include "hmac.h"
#include "errorctx.h"

int HMACInit (
   VoltAlgorithmObject *hmacObject,
   VoltKeyObject *keyObject   
   )
{
  int status;
  unsigned int index;
  VoltLibCtx *libCtx = (VoltLibCtx *)(hmacObject->voltObject.libraryCtx);
  VoltMACClassCtx *macCtx = (VoltMACClassCtx *)hmacObject->classCtx;
  VoltHMACCtx *hmacCtx = (VoltHMACCtx *)macCtx->localMacCtx;
  VoltAlgorithmObject *digestObj = hmacCtx->digestObj;
  VoltDigestClassCtx *digestCtx = (VoltDigestClassCtx *)(digestObj->classCtx);
  unsigned int blockLen = digestCtx->blockLen;
  VtItem *keyData = (VtItem *)0;
  VOLT_DECLARE_ERROR_TYPE (errorType)
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do 
  {    
    /* Make sure the key matches the algorithm object.
     */
    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_INVALID_KEY_OBJ;
    if ((keyObject->keyType & VOLT_KEY_TYPE_MASK_MAC_ALG) != VOLT_KEY_ALG_HMAC)
      break;

    /* We need data (status is still set to VT_ERROR_INVALID_KEY_OBJ if we
     * can't get the data out).
     */
    keyData = (VtItem *)(keyObject->keyData);
    if ((keyObject->keyType & VOLT_KEY_TYPE_MASK_DATA) != VOLT_KEY_TYPE_DATA)
    {
      if (keyObject->GetKeyData == (VGetKeyData)0)
        break;

      VOLT_SET_ERROR_TYPE (errorType, 0)
      VOLT_SET_FNCT_LINE (fnctLine)
      status = keyObject->GetKeyData (
        (VtKeyObject)keyObject, (Pointer *)&keyData);
      if (status != 0)
        break;
    }

    /* If the key is larger than the block size of the underlying
     * digest algorithm, reset the key by digesting it.
     */
    VOLT_SET_ERROR_TYPE (errorType, 0)
    if (keyData->len > blockLen) 
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = VtDigestInit (digestObj);
      if (status != 0)
        break;

      VOLT_SET_FNCT_LINE (fnctLine)
      status = VtDigestFinal (
        digestObj, keyData->data, keyData->len, hmacCtx->key, blockLen, 
        &(hmacCtx->keyLen));
      if (status != 0 )
        break;
    }
    else
    {
      Z2Memcpy (hmacCtx->key, keyData->data , keyData->len);
      hmacCtx->keyLen = keyData->len;
    }

    /* The internal representation of the key is the following:
     *   1. ipad = 36 36 ... 36 (blockLen bytes of 0x36)
     *   2. opad = 5c 5c ... 5c (blockLen bytes of 0x5c)
     *   3. for as many key bytes as there are, XOR each byte of key
     *   with a byte of ipad, then with a byte of opad.
     */
    Z2Memset (hmacCtx->ipad, 0x36, blockLen);
    Z2Memset (hmacCtx->opad, 0x5c, blockLen);

    for (index = 0; index < hmacCtx->keyLen; ++index)
    {
      hmacCtx->ipad[index] ^= hmacCtx->key[index];
      hmacCtx->opad[index] ^= hmacCtx->key[index];
    }

    /* Now digest the ipad for inner pad 
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestInit (digestObj);
    if (status != 0 )
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestUpdate (digestObj, hmacCtx->ipad, blockLen);
    if (status != 0 )
      break;
   
  } while (0) ; 

  VOLT_LOG_ERROR_COMPARE (
    status, (VtLibCtx)libCtx, status, errorType, fnctLine,
    "HMACInit", (char *)0)

  return status ;
}

int HMACUpdate (
    VoltAlgorithmObject *hmacObject,
    unsigned char *data,
    unsigned int dataLen
    )
{
  unsigned int status = 0;
  VoltMACClassCtx *macCtx = (VoltMACClassCtx *)hmacObject->classCtx;
  VoltHMACCtx *hmacCtx = (VoltHMACCtx *)macCtx->localMacCtx ;
  VoltAlgorithmObject *digestObj = hmacCtx->digestObj ;  
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  /* Continue digesting the data.
   */
  VOLT_SET_FNCT_LINE (fnctLine)
  status = VtDigestUpdate (digestObj, data, dataLen);
  
  VOLT_LOG_ERROR_COMPARE (
    status, hmacObject->voltObject.libraryCtx, status, 0, fnctLine,
    "HMACUpdate", (char *)0)

  return (status);
}

int HMACFinal (
    VoltAlgorithmObject *hmacObject,
    unsigned char *mac    
    )
{
  unsigned int status = 0;  
  unsigned int hashLen, len;     
  VoltMACClassCtx *macCtx = (VoltMACClassCtx *)hmacObject->classCtx;
  VoltHMACCtx *hmacCtx = (VoltHMACCtx *)macCtx->localMacCtx ;
  VoltAlgorithmObject *digestObj = hmacCtx->digestObj ;  
  VoltDigestClassCtx *digestCtx = (VoltDigestClassCtx *)digestObj->classCtx ; 
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    /* First calculate the digest on ipad || message
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestFinal (
      digestObj, (unsigned char *)0, 0, hmacCtx->ipadHash,
      digestCtx->digestSize, &hashLen);

    /* calculate the digest on opad
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestInit (digestObj);
    if (status != 0 )
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestUpdate (digestObj, hmacCtx->opad, digestCtx->blockLen);
    if (status != 0 )
      break;

    /* The final digest is digest (opad || ipadHash)
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestFinal (
      digestObj, hmacCtx->ipadHash, hashLen, mac, digestCtx->digestSize, &len);

  } while (0);
  
  VOLT_LOG_ERROR_COMPARE (
    status, hmacObject->voltObject.libraryCtx, status, 0, fnctLine,
    "HMACFinal", (char *)0)

  return (status);
}