Mercurial > vba-linux

     1 // HmacSha1.cpp

     2 

     3 #include "StdAfx.h"

     4 

     5 #include "HmacSha1.h"

     6 

     7 namespace NCrypto {

     8 namespace NSha1 {

     9 

    10 void CHmac::SetKey(const Byte *key, size_t keySize)

    11 {

    12   Byte keyTemp[kBlockSize];

    13   size_t i;

    14   for (i = 0; i < kBlockSize; i++)

    15     keyTemp[i] = 0;

    16   if(keySize > kBlockSize)

    17   {

    18     _sha.Init();

    19     _sha.Update(key, keySize);

    20     _sha.Final(keyTemp);

    21     keySize = kDigestSize;

    22   }

    23   else

    24     for (i = 0; i < keySize; i++)

    25       keyTemp[i] = key[i];

    26   for (i = 0; i < kBlockSize; i++)

    27     keyTemp[i] ^= 0x36;

    28   _sha.Init();

    29   _sha.Update(keyTemp, kBlockSize);

    30   for (i = 0; i < kBlockSize; i++)

    31     keyTemp[i] ^= 0x36 ^ 0x5C;

    32   _sha2.Init();

    33   _sha2.Update(keyTemp, kBlockSize);

    34 }

    35 

    36 void CHmac::Final(Byte *mac, size_t macSize)

    37 {

    38   Byte digest[kDigestSize];

    39   _sha.Final(digest);

    40   _sha2.Update(digest, kDigestSize);

    41   _sha2.Final(digest);

    42   for(size_t i = 0; i < macSize; i++)

    43     mac[i] = digest[i];

    44 }

    45 

    46 

    47 void CHmac32::SetKey(const Byte *key, size_t keySize)

    48 {

    49   UInt32 keyTemp[kBlockSizeInWords];

    50   size_t i;

    51   for (i = 0; i < kBlockSizeInWords; i++)

    52     keyTemp[i] = 0;

    53   if(keySize > kBlockSize)

    54   {

    55     CContext sha;

    56     sha.Init();

    57     sha.Update(key, keySize);

    58     Byte digest[kDigestSize];

    59     sha.Final(digest);

    60     

    61     for (int i = 0 ; i < kDigestSizeInWords; i++)

    62       keyTemp[i] =

    63           ((UInt32)(digest[i * 4 + 0]) << 24) |

    64           ((UInt32)(digest[i * 4 + 1]) << 16) |

    65           ((UInt32)(digest[i * 4 + 2]) <<  8) |

    66           ((UInt32)(digest[i * 4 + 3]));

    67     keySize = kDigestSizeInWords;

    68   }

    69   else

    70     for (size_t i = 0; i < keySize; i++)

    71       keyTemp[i / 4] |= (key[i] << (24 - 8 * (i & 3)));

    72   for (i = 0; i < kBlockSizeInWords; i++)

    73     keyTemp[i] ^= 0x36363636;

    74   _sha.Init();

    75   _sha.Update(keyTemp, kBlockSizeInWords);

    76   for (i = 0; i < kBlockSizeInWords; i++)

    77     keyTemp[i] ^= 0x36363636 ^ 0x5C5C5C5C;

    78   _sha2.Init();

    79   _sha2.Update(keyTemp, kBlockSizeInWords);

    80 }

    81 

    82 void CHmac32::Final(UInt32 *mac, size_t macSize)

    83 {

    84   UInt32 digest[kDigestSizeInWords];

    85   _sha.Final(digest);

    86   _sha2.Update(digest, kDigestSizeInWords);

    87   _sha2.Final(digest);

    88   for(size_t i = 0; i < macSize; i++)

    89     mac[i] = digest[i];

    90 }

    91 

    92 void CHmac32::GetLoopXorDigest(UInt32 *mac, UInt32 numIteration)

    93 {

    94   UInt32 block[kBlockSizeInWords];

    95   UInt32 block2[kBlockSizeInWords];

    96   _sha.PrepareBlock(block, kDigestSizeInWords);

    97   _sha2.PrepareBlock(block2, kDigestSizeInWords);

    98   for(unsigned int s = 0; s < kDigestSizeInWords; s++)

    99     block[s] = mac[s];

   100   for(UInt32 i = 0; i < numIteration; i++)

   101   {

   102     _sha.GetBlockDigest(block, block2);

   103     _sha2.GetBlockDigest(block2, block);

   104     for (unsigned int s = 0; s < kDigestSizeInWords; s++)

   105       mac[s] ^= block[s];

   106   }

   107 }

   108 

   109 }}
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 03 Mar 2012 10:31:27 -0600
parents
children