hmacimpl.c

voltage 公司提供的一个开发Ibe的工具包

/* Copyright 2003-2005, 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   
   )
{
  unsigned int status = 0, 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 
  {    
    /* If no key object keep the last secret that was set. This will be helpful
     * if we don't want to change the secret for performing HMAC on multiple
     * data because we don't have to create a key object, just pass NULL.
     */
    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    if (keyObject == (VoltKeyObject *)0 )
    {  
      VOLT_SET_FNCT_LINE (fnctLine)
      status = VT_ERROR_INVALID_KEY_OBJ;
      if (hmacCtx->key == (unsigned char *)0)
        break;     
    }
    else 
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = VT_ERROR_INVALID_KEY_OBJ;
      if ((keyObject->keyType & VOLT_KEY_TYPE_MASK_MAC_ALG) != VOLT_KEY_ALG_MAC)
        break;
      
      /* We need data the key data.
      */
      VOLT_SET_FNCT_LINE (fnctLine)
      keyData = (VtItem *)(keyObject->keyData);
      if (keyData == (VtItem *) 0)
        break;
      if ((keyObject->keyType & VOLT_KEY_TYPE_MASK_DATA) != VOLT_KEY_TYPE_DATA)
      {
        VOLT_SET_FNCT_LINE (fnctLine)
        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 key is larger than the block size of 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;
      }
      Z2Memset (hmacCtx->ipad, 0, blockLen);
      Z2Memcpy (hmacCtx->ipad, hmacCtx->key, hmacCtx->keyLen);
      Z2Memset (hmacCtx->opad, 0 , blockLen);
      Z2Memcpy (hmacCtx->opad, hmacCtx->key, hmacCtx->keyLen);

      for (index=0 ; index < blockLen; index++)
      {
        hmacCtx->ipad[index] ^= 0x36;
        hmacCtx->opad[index] ^= 0x5c;
      }
    } /* else */

    /* Now digest the data 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)

  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
     */
    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
     */
    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);
}

/* This is a utility function HMAC function. It uses Sha1 as underlying
 * digest method. It is used by delegated transport provider. It assumes that 
 * caller has access to the secret.
 */   
int VoltHMAC_SHA1 (
   VoltLibCtx *libCtx,                   
   unsigned char *secret,
   unsigned int secretLen,
   unsigned char *data,
   unsigned int dataLen,
   unsigned char *digest,
   unsigned int bufferSize,
   unsigned int *digestLen
   )
{
  unsigned char iPad[64];
  unsigned char oPad[64];
  unsigned char iDigest[20];  
  unsigned char actualKey[20];
  unsigned int actualKeyLen = 20;
  unsigned int status =0,i, outLen;
  VtAlgorithmObject digestObj = (VtAlgorithmObject)0;
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtCreateAlgorithmObject (
      libCtx, VtAlgorithmImplSHA1, (Pointer)0, &digestObj);
    if (status != 0)
      break;
    /* If the key size is greater than 64 bytes compute the Sha1 of the key
     */
    if (secretLen > 64)
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = VtDigestInit (digestObj);
      if (status != 0 )
        break; 

      VOLT_SET_FNCT_LINE (fnctLine)
      status = VtDigestFinal (
        digestObj, secret, secretLen, actualKey, 20, &outLen);
      if (status != 0 )
        break; 
      actualKeyLen = 20;
    }
    else
    {
      Z2Memcpy (actualKey, secret, secretLen);
      actualKeyLen = secretLen;
    }

    Z2Memset (iPad , 0, 64);
    Z2Memcpy (iPad, actualKey, actualKeyLen);
    Z2Memset (oPad , 0 , 64);
    Z2Memcpy (oPad, actualKey, actualKeyLen);

    for (i=0 ; i < 64; i++)
    {
      iPad[i] ^= 0x36;
      oPad[i] ^= 0x5c;
    }
    /* Digest the data for inner pad
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestInit (digestObj);
    if (status != 0 )
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestUpdate (digestObj, iPad, 64);
    if (status != 0 )
      break;    

    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestFinal (
      digestObj, data, dataLen, iDigest, 20, &outLen);
    if (status != 0 )
      break;  

    /* Now digest the oPad
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestInit (digestObj);
    if (status != 0 )
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestUpdate (digestObj, oPad, 64);
    if (status != 0 )
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtDigestFinal (
      digestObj, iDigest, 20, digest, bufferSize, digestLen);
    if (status != 0 )
      break;

  } while (0);

  VtDestroyAlgorithmObject (&digestObj);

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

  return (status);
}