seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Crypto/7zAes.cpp

@@ -4,9 +4,12 @@
 
 #include "../../../C/Sha256.h"
 
-#include "Windows/Synchronization.h"
+#include "../../Common/ComTry.h"
+
+#ifndef _7ZIP_ST
+#include "../../Windows/Synchronization.h"
+#endif
 
-#include "../Common/StreamObjects.h"
 #include "../Common/StreamUtils.h"
 
 #include "7zAes.h"
@@ -16,106 +19,134 @@
 #include "RandGen.h"
 #endif
 
-using namespace NWindows;
-
 namespace NCrypto {
-namespace NSevenZ {
+namespace N7z {
+
+static const unsigned k_NumCyclesPower_Supported_MAX = 24;
 
 bool CKeyInfo::IsEqualTo(const CKeyInfo &a) const
 {
   if (SaltSize != a.SaltSize || NumCyclesPower != a.NumCyclesPower)
     return false;
-  for (UInt32 i = 0; i < SaltSize; i++)
+  for (unsigned i = 0; i < SaltSize; i++)
     if (Salt[i] != a.Salt[i])
       return false;
   return (Password == a.Password);
 }
 
-void CKeyInfo::CalculateDigest()
+void CKeyInfo::CalcKey()
 {
   if (NumCyclesPower == 0x3F)
   {
-    UInt32 pos;
+    unsigned pos;
     for (pos = 0; pos < SaltSize; pos++)
       Key[pos] = Salt[pos];
-    for (UInt32 i = 0; i < Password.GetCapacity() && pos < kKeySize; i++)
+    for (unsigned i = 0; i < Password.Size() && pos < kKeySize; i++)
       Key[pos++] = Password[i];
     for (; pos < kKeySize; pos++)
       Key[pos] = 0;
   }
   else
   {
+    size_t bufSize = 8 + SaltSize + Password.Size();
+    CObjArray<Byte> buf(bufSize);
+    memcpy(buf, Salt, SaltSize);
+    memcpy(buf + SaltSize, Password, Password.Size());
+    
     CSha256 sha;
     Sha256_Init(&sha);
-    const UInt64 numRounds = (UInt64)1 << NumCyclesPower;
-    Byte temp[8] = { 0,0,0,0,0,0,0,0 };
-    for (UInt64 round = 0; round < numRounds; round++)
+    
+    Byte *ctr = buf + SaltSize + Password.Size();
+    
+    for (unsigned i = 0; i < 8; i++)
+      ctr[i] = 0;
+    
+    UInt64 numRounds = (UInt64)1 << NumCyclesPower;
+
+    do
     {
-      Sha256_Update(&sha, Salt, (size_t)SaltSize);
-      Sha256_Update(&sha, Password, Password.GetCapacity());
-      Sha256_Update(&sha, temp, 8);
-      for (int i = 0; i < 8; i++)
-        if (++(temp[i]) != 0)
+      Sha256_Update(&sha, buf, bufSize);
+      for (unsigned i = 0; i < 8; i++)
+        if (++(ctr[i]) != 0)
           break;
     }
+    while (--numRounds != 0);
+
     Sha256_Final(&sha, Key);
   }
 }
 
-bool CKeyInfoCache::Find(CKeyInfo &key)
+bool CKeyInfoCache::GetKey(CKeyInfo &key)
 {
-  for (int i = 0; i < Keys.Size(); i++)
+  FOR_VECTOR (i, Keys)
   {
     const CKeyInfo &cached = Keys[i];
     if (key.IsEqualTo(cached))
     {
-      for (int j = 0; j < kKeySize; j++)
+      for (unsigned j = 0; j < kKeySize; j++)
         key.Key[j] = cached.Key[j];
       if (i != 0)
-      {
-        Keys.Insert(0, cached);
-        Keys.Delete(i+1);
-      }
+        Keys.MoveToFront(i);
       return true;
     }
   }
   return false;
 }
 
-void CKeyInfoCache::Add(CKeyInfo &key)
+void CKeyInfoCache::FindAndAdd(const CKeyInfo &key)
+{
+  FOR_VECTOR (i, Keys)
+  {
+    const CKeyInfo &cached = Keys[i];
+    if (key.IsEqualTo(cached))
+    {
+      if (i != 0)
+        Keys.MoveToFront(i);
+      return;
+    }
+  }
+  Add(key);
+}
+
+void CKeyInfoCache::Add(const CKeyInfo &key)
 {
-  if (Find(key))
-    return;
   if (Keys.Size() >= Size)
     Keys.DeleteBack();
   Keys.Insert(0, key);
 }
 
 static CKeyInfoCache g_GlobalKeyCache(32);
-static NSynchronization::CCriticalSection g_GlobalKeyCacheCriticalSection;
+
+#ifndef _7ZIP_ST
+  static NWindows::NSynchronization::CCriticalSection g_GlobalKeyCacheCriticalSection;
+  #define MT_LOCK NWindows::NSynchronization::CCriticalSectionLock lock(g_GlobalKeyCacheCriticalSection);
+#else
+  #define MT_LOCK
+#endif
 
 CBase::CBase():
   _cachedKeys(16),
   _ivSize(0)
 {
-  for (int i = 0; i < sizeof(_iv); i++)
+  for (unsigned i = 0; i < sizeof(_iv); i++)
     _iv[i] = 0;
 }
 
-void CBase::CalculateDigest()
+void CBase::PrepareKey()
 {
-  NSynchronization::CCriticalSectionLock lock(g_GlobalKeyCacheCriticalSection);
-  if (_cachedKeys.Find(_key))
-    g_GlobalKeyCache.Add(_key);
-  else
+  // BCJ2 threads use same password. So we use long lock.
+  MT_LOCK
+  
+  bool finded = false;
+  if (!_cachedKeys.GetKey(_key))
   {
-    if (!g_GlobalKeyCache.Find(_key))
-    {
-      _key.CalculateDigest();
-      g_GlobalKeyCache.Add(_key);
-    }
+    finded = g_GlobalKeyCache.GetKey(_key);
+    if (!finded)
+      _key.CalcKey();
     _cachedKeys.Add(_key);
   }
+  if (!finded)
+    g_GlobalKeyCache.FindAndAdd(_key);
 }
 
 #ifndef EXTRACT_ONLY
@@ -131,103 +162,114 @@ STDMETHODIMP CEncoder::ResetSalt()
 
 STDMETHODIMP CEncoder::ResetInitVector()
 {
+  for (unsigned i = 0; i < sizeof(_iv); i++)
+    _iv[i] = 0;
   _ivSize = 8;
-  g_RandomGenerator.Generate(_iv, (unsigned)_ivSize);
+  g_RandomGenerator.Generate(_iv, _ivSize);
   return S_OK;
 }
 
 STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
 {
-   // _key.Init();
-   for (UInt32 i = _ivSize; i < sizeof(_iv); i++)
-    _iv[i] = 0;
+  Byte props[2 + sizeof(_key.Salt) + sizeof(_iv)];
+  unsigned propsSize = 1;
 
-  UInt32 ivSize = _ivSize;
-  
-  // _key.NumCyclesPower = 0x3F;
-  _key.NumCyclesPower = 19;
+  props[0] = (Byte)(_key.NumCyclesPower
+      | (_key.SaltSize == 0 ? 0 : (1 << 7))
+      | (_ivSize       == 0 ? 0 : (1 << 6)));
 
-  Byte firstByte = (Byte)(_key.NumCyclesPower |
-    (((_key.SaltSize == 0) ? 0 : 1) << 7) |
-    (((ivSize == 0) ? 0 : 1) << 6));
-  RINOK(outStream->Write(&firstByte, 1, NULL));
-  if (_key.SaltSize == 0 && ivSize == 0)
-    return S_OK;
-  Byte saltSizeSpec = (Byte)((_key.SaltSize == 0) ? 0 : (_key.SaltSize - 1));
-  Byte ivSizeSpec = (Byte)((ivSize == 0) ? 0 : (ivSize - 1));
-  Byte secondByte = (Byte)(((saltSizeSpec) << 4) | ivSizeSpec);
-  RINOK(outStream->Write(&secondByte, 1, NULL));
-  if (_key.SaltSize > 0)
+  if (_key.SaltSize != 0 || _ivSize != 0)
   {
-    RINOK(WriteStream(outStream, _key.Salt, _key.SaltSize));
+    props[1] = (Byte)(
+        ((_key.SaltSize == 0 ? 0 : _key.SaltSize - 1) << 4)
+        | (_ivSize      == 0 ? 0 : _ivSize - 1));
+    memcpy(props + 2, _key.Salt, _key.SaltSize);
+    propsSize = 2 + _key.SaltSize;
+    memcpy(props + propsSize, _iv, _ivSize);
+    propsSize += _ivSize;
   }
-  if (ivSize > 0)
-  {
-    RINOK(WriteStream(outStream, _iv, ivSize));
-  }
-  return S_OK;
+
+  return WriteStream(outStream, props, propsSize);
 }
 
-HRESULT CEncoder::CreateFilter()
+CEncoder::CEncoder()
 {
-  _aesFilter = new CAesCbcEncoder;
-  return S_OK;
+  // _key.SaltSize = 4; g_RandomGenerator.Generate(_key.Salt, _key.SaltSize);
+  // _key.NumCyclesPower = 0x3F;
+  _key.NumCyclesPower = 19;
+  _aesFilter = new CAesCbcEncoder(kKeySize);
 }
 
 #endif
 
+CDecoder::CDecoder()
+{
+  _aesFilter = new CAesCbcDecoder(kKeySize);
+}
+
 STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
 {
-  _key.Init();
-  UInt32 i;
+  _key.ClearProps();
+ 
+  _ivSize = 0;
+  unsigned i;
   for (i = 0; i < sizeof(_iv); i++)
     _iv[i] = 0;
+  
   if (size == 0)
     return S_OK;
-  UInt32 pos = 0;
-  Byte firstByte = data[pos++];
+  
+  Byte b0 = data[0];
 
-  _key.NumCyclesPower = firstByte & 0x3F;
-  if ((firstByte & 0xC0) == 0)
-    return S_OK;
-  _key.SaltSize = (firstByte >> 7) & 1;
-  UInt32 ivSize = (firstByte >> 6) & 1;
+  _key.NumCyclesPower = b0 & 0x3F;
+  if ((b0 & 0xC0) == 0)
+    return size == 1 ? S_OK : E_INVALIDARG;
 
-  if (pos >= size)
+  if (size <= 1)
     return E_INVALIDARG;
-  Byte secondByte = data[pos++];
-  
-  _key.SaltSize += (secondByte >> 4);
-  ivSize += (secondByte & 0x0F);
+
+  Byte b1 = data[1];
+
+  unsigned saltSize = ((b0 >> 7) & 1) + (b1 >> 4);
+  unsigned ivSize   = ((b0 >> 6) & 1) + (b1 & 0x0F);
   
-  if (pos + _key.SaltSize + ivSize > size)
+  if (size != 2 + saltSize + ivSize)
     return E_INVALIDARG;
-  for (i = 0; i < _key.SaltSize; i++)
-    _key.Salt[i] = data[pos++];
+  _key.SaltSize = saltSize;
+  data += 2;
+  for (i = 0; i < saltSize; i++)
+    _key.Salt[i] = *data++;
   for (i = 0; i < ivSize; i++)
-    _iv[i] = data[pos++];
-  return (_key.NumCyclesPower <= 24) ? S_OK :  E_NOTIMPL;
+    _iv[i] = *data++;
+  return (_key.NumCyclesPower <= k_NumCyclesPower_Supported_MAX
+      || _key.NumCyclesPower == 0x3F) ? S_OK : E_NOTIMPL;
 }
 
+
 STDMETHODIMP CBaseCoder::CryptoSetPassword(const Byte *data, UInt32 size)
 {
-  _key.Password.SetCapacity((size_t)size);
-  memcpy(_key.Password, data, (size_t)size);
+  COM_TRY_BEGIN
+  
+  _key.Password.CopyFrom(data, (size_t)size);
   return S_OK;
+  
+  COM_TRY_END
 }
 
 STDMETHODIMP CBaseCoder::Init()
 {
-  CalculateDigest();
-  if (_aesFilter == 0)
-  {
-    RINOK(CreateFilter());
-  }
+  COM_TRY_BEGIN
+  
+  PrepareKey();
   CMyComPtr<ICryptoProperties> cp;
   RINOK(_aesFilter.QueryInterface(IID_ICryptoProperties, &cp));
-  RINOK(cp->SetKey(_key.Key, sizeof(_key.Key)));
+  if (!cp)
+    return E_FAIL;
+  RINOK(cp->SetKey(_key.Key, kKeySize));
   RINOK(cp->SetInitVector(_iv, sizeof(_iv)));
-  return S_OK;
+  return _aesFilter->Init();
+  
+  COM_TRY_END
 }
 
 STDMETHODIMP_(UInt32) CBaseCoder::Filter(Byte *data, UInt32 size)
@@ -235,10 +277,4 @@ STDMETHODIMP_(UInt32) CBaseCoder::Filter(Byte *data, UInt32 size)
   return _aesFilter->Filter(data, size);
 }
 
-HRESULT CDecoder::CreateFilter()
-{
-  _aesFilter = new CAesCbcDecoder;
-  return S_OK;
-}
-
 }}

data/ext/p7zip/CPP/7zip/Crypto/7zAes.h

@@ -3,49 +3,51 @@
 #ifndef __CRYPTO_7Z_AES_H
 #define __CRYPTO_7Z_AES_H
 
-#include "Common/Buffer.h"
-#include "Common/MyCom.h"
-#include "Common/MyVector.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
 
 #include "../ICoder.h"
 #include "../IPassword.h"
 
 namespace NCrypto {
-namespace NSevenZ {
+namespace N7z {
 
-const int kKeySize = 32;
+const unsigned kKeySize = 32;
+const unsigned kSaltSizeMax = 16;
+const unsigned kIvSizeMax = 16; // AES_BLOCK_SIZE;
 
 class CKeyInfo
 {
 public:
-  int NumCyclesPower;
-  UInt32 SaltSize;
-  Byte Salt[16];
+  unsigned NumCyclesPower;
+  unsigned SaltSize;
+  Byte Salt[kSaltSizeMax];
   CByteBuffer Password;
   Byte Key[kKeySize];
 
   bool IsEqualTo(const CKeyInfo &a) const;
-  void CalculateDigest();
+  void CalcKey();
 
-  CKeyInfo() { Init(); }
-  void Init()
+  CKeyInfo() { ClearProps(); }
+  void ClearProps()
   {
     NumCyclesPower = 0;
     SaltSize = 0;
-    for (int i = 0; i < sizeof(Salt); i++)
+    for (unsigned i = 0; i < sizeof(Salt); i++)
       Salt[i] = 0;
   }
 };
 
 class CKeyInfoCache
 {
-  int Size;
+  unsigned Size;
   CObjectVector<CKeyInfo> Keys;
 public:
-  CKeyInfoCache(int size): Size(size) {}
-  bool Find(CKeyInfo &key);
-  // HRESULT Calculate(CKeyInfo &key);
-  void Add(CKeyInfo &key);
+  CKeyInfoCache(unsigned size): Size(size) {}
+  bool GetKey(CKeyInfo &key);
+  void Add(const CKeyInfo &key);
+  void FindAndAdd(const CKeyInfo &key);
 };
 
 class CBase
@@ -53,9 +55,10 @@ class CBase
   CKeyInfoCache _cachedKeys;
 protected:
   CKeyInfo _key;
-  Byte _iv[16];
-  UInt32 _ivSize;
-  void CalculateDigest();
+  Byte _iv[kIvSizeMax];
+  unsigned _ivSize;
+  
+  void PrepareKey();
   CBase();
 };
 
@@ -68,13 +71,8 @@ class CBaseCoder:
 protected:
   CMyComPtr<ICompressFilter> _aesFilter;
 
-  virtual HRESULT CreateFilter() = 0;
-  #ifndef CRYPTO_AES
-  HRESULT CreateFilterFromDLL(REFCLSID clsID);
-  #endif
 public:
-  STDMETHOD(Init)();
-  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  INTERFACE_ICompressFilter(;)
   
   STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
 };
@@ -87,9 +85,9 @@ class CEncoder:
   // public ICryptoResetSalt,
   public ICryptoResetInitVector
 {
-  virtual HRESULT CreateFilter();
 public:
-  MY_UNKNOWN_IMP3(
+  MY_UNKNOWN_IMP4(
+      ICompressFilter,
       ICryptoSetPassword,
       ICompressWriteCoderProperties,
       // ICryptoResetSalt,
@@ -97,19 +95,22 @@ public:
   STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
   // STDMETHOD(ResetSalt)();
   STDMETHOD(ResetInitVector)();
+  CEncoder();
 };
+
 #endif
 
 class CDecoder:
   public CBaseCoder,
   public ICompressSetDecoderProperties2
 {
-  virtual HRESULT CreateFilter();
 public:
-  MY_UNKNOWN_IMP2(
+  MY_UNKNOWN_IMP3(
+      ICompressFilter,
       ICryptoSetPassword,
       ICompressSetDecoderProperties2)
   STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
+  CDecoder();
 };
 
 }}

data/ext/p7zip/CPP/7zip/Crypto/7zAesRegister.cpp

@@ -3,16 +3,15 @@
 #include "StdAfx.h"
 
 #include "../Common/RegisterCodec.h"
+
 #include "7zAes.h"
 
-static void *CreateCodec() { return (void *)(ICompressFilter *)(new NCrypto::NSevenZ::CDecoder()); }
-#ifndef EXTRACT_ONLY
-static void *CreateCodecOut() { return (void *)(ICompressFilter *)(new NCrypto::NSevenZ::CEncoder()); }
-#else
-#define CreateCodecOut 0
-#endif
+namespace NCrypto {
+namespace N7z {
 
-static CCodecInfo g_CodecInfo =
-  { CreateCodec, CreateCodecOut, 0x06F10701, L"7zAES", 1, true };
+REGISTER_FILTER_E(7zAES,
+    CDecoder(),
+    CEncoder(),
+    0x6F10701, "7zAES")
 
-REGISTER_CODEC(7zAES)
+}}

data/ext/p7zip/CPP/7zip/Crypto/HmacSha1.cpp

@@ -2,6 +2,8 @@
 
 #include "StdAfx.h"
 
+#include "../../../C/CpuArch.h"
+
 #include "HmacSha1.h"
 
 namespace NCrypto {
@@ -11,24 +13,29 @@ void CHmac::SetKey(const Byte *key, size_t keySize)
 {
   Byte keyTemp[kBlockSize];
   size_t i;
+  
   for (i = 0; i < kBlockSize; i++)
     keyTemp[i] = 0;
-  if(keySize > kBlockSize)
+  
+  if (keySize > kBlockSize)
   {
     _sha.Init();
     _sha.Update(key, keySize);
     _sha.Final(keyTemp);
-    keySize = kDigestSize;
   }
   else
     for (i = 0; i < keySize; i++)
       keyTemp[i] = key[i];
+  
   for (i = 0; i < kBlockSize; i++)
     keyTemp[i] ^= 0x36;
+  
   _sha.Init();
   _sha.Update(keyTemp, kBlockSize);
+  
   for (i = 0; i < kBlockSize; i++)
     keyTemp[i] ^= 0x36 ^ 0x5C;
+
   _sha2.Init();
   _sha2.Update(keyTemp, kBlockSize);
 }
@@ -39,18 +46,20 @@ void CHmac::Final(Byte *mac, size_t macSize)
   _sha.Final(digest);
   _sha2.Update(digest, kDigestSize);
   _sha2.Final(digest);
-  for(size_t i = 0; i < macSize; i++)
+  for (size_t i = 0; i < macSize; i++)
     mac[i] = digest[i];
 }
 
 
 void CHmac32::SetKey(const Byte *key, size_t keySize)
 {
-  UInt32 keyTemp[kBlockSizeInWords];
+  UInt32 keyTemp[kNumBlockWords];
   size_t i;
-  for (i = 0; i < kBlockSizeInWords; i++)
+  
+  for (i = 0; i < kNumBlockWords; i++)
     keyTemp[i] = 0;
-  if(keySize > kBlockSize)
+  
+  if (keySize > kBlockSize)
   {
     CContext sha;
     sha.Init();
@@ -58,50 +67,52 @@ void CHmac32::SetKey(const Byte *key, size_t keySize)
     Byte digest[kDigestSize];
     sha.Final(digest);
     
-    for (int i = 0 ; i < kDigestSizeInWords; i++)
-      keyTemp[i] =
-          ((UInt32)(digest[i * 4 + 0]) << 24) |
-          ((UInt32)(digest[i * 4 + 1]) << 16) |
-          ((UInt32)(digest[i * 4 + 2]) <<  8) |
-          ((UInt32)(digest[i * 4 + 3]));
-    keySize = kDigestSizeInWords;
+    for (i = 0 ; i < kNumDigestWords; i++)
+      keyTemp[i] = GetBe32(digest + i * 4 + 0);
   }
   else
-    for (size_t i = 0; i < keySize; i++)
+    for (i = 0; i < keySize; i++)
       keyTemp[i / 4] |= (key[i] << (24 - 8 * (i & 3)));
-  for (i = 0; i < kBlockSizeInWords; i++)
+  
+  for (i = 0; i < kNumBlockWords; i++)
     keyTemp[i] ^= 0x36363636;
+  
   _sha.Init();
-  _sha.Update(keyTemp, kBlockSizeInWords);
-  for (i = 0; i < kBlockSizeInWords; i++)
+  _sha.Update(keyTemp, kNumBlockWords);
+  
+  for (i = 0; i < kNumBlockWords; i++)
     keyTemp[i] ^= 0x36363636 ^ 0x5C5C5C5C;
+  
   _sha2.Init();
-  _sha2.Update(keyTemp, kBlockSizeInWords);
+  _sha2.Update(keyTemp, kNumBlockWords);
 }
 
 void CHmac32::Final(UInt32 *mac, size_t macSize)
 {
-  UInt32 digest[kDigestSizeInWords];
+  UInt32 digest[kNumDigestWords];
   _sha.Final(digest);
-  _sha2.Update(digest, kDigestSizeInWords);
+  _sha2.Update(digest, kNumDigestWords);
   _sha2.Final(digest);
-  for(size_t i = 0; i < macSize; i++)
+  for (size_t i = 0; i < macSize; i++)
     mac[i] = digest[i];
 }
 
 void CHmac32::GetLoopXorDigest(UInt32 *mac, UInt32 numIteration)
 {
-  UInt32 block[kBlockSizeInWords];
-  UInt32 block2[kBlockSizeInWords];
-  _sha.PrepareBlock(block, kDigestSizeInWords);
-  _sha2.PrepareBlock(block2, kDigestSizeInWords);
-  for(unsigned int s = 0; s < kDigestSizeInWords; s++)
+  UInt32 block[kNumBlockWords];
+  UInt32 block2[kNumBlockWords];
+  
+  _sha.PrepareBlock(block, kNumDigestWords);
+  _sha2.PrepareBlock(block2, kNumDigestWords);
+
+  for (unsigned s = 0; s < kNumDigestWords; s++)
     block[s] = mac[s];
-  for(UInt32 i = 0; i < numIteration; i++)
+  
+  for (UInt32 i = 0; i < numIteration; i++)
   {
     _sha.GetBlockDigest(block, block2);
     _sha2.GetBlockDigest(block2, block);
-    for (unsigned int s = 0; s < kDigestSizeInWords; s++)
+    for (unsigned s = 0; s < kNumDigestWords; s++)
       mac[s] ^= block[s];
   }
 }

data/ext/p7zip/CPP/7zip/Crypto/HmacSha1.h

@@ -4,7 +4,7 @@
 #ifndef __CRYPTO_HMAC_SHA1_H
 #define __CRYPTO_HMAC_SHA1_H
 
-#include "Sha1.h"
+#include "Sha1Cls.h"
 
 namespace NCrypto {
 namespace NSha1 {
@@ -28,9 +28,9 @@ class CHmac32
 public:
   void SetKey(const Byte *key, size_t keySize);
   void Update(const UInt32 *data, size_t dataSize) { _sha.Update(data, dataSize); }
-  void Final(UInt32 *mac, size_t macSize = kDigestSizeInWords);
+  void Final(UInt32 *mac, size_t macSize = kNumDigestWords);
   
-  // It'sa for hmac function. in,out: mac[kDigestSizeInWords].
+  // It'sa for hmac function. in,out: mac[kNumDigestWords].
   void GetLoopXorDigest(UInt32 *mac, UInt32 numIteration);
 };