seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -3,46 +3,44 @@
 #ifndef __CRYPTO_RAR20_CRYPTO_H
 #define __CRYPTO_RAR20_CRYPTO_H
 
-#include "Common/MyCom.h"
+#include "../../Common/MyCom.h"
 
 #include "../ICoder.h"
-#include "../IPassword.h"
 
 namespace NCrypto {
-namespace NRar20 {
+namespace NRar2 {
+
+/* ICompressFilter::Init() does nothing for this filter.
+   Call SetPassword() to initialize filter. */
 
 class CData
 {
   Byte SubstTable[256];
   UInt32 Keys[4];
   
-  UInt32 SubstLong(UInt32 t)
+  UInt32 SubstLong(UInt32 t) const
   {
-    return (UInt32)SubstTable[(int)t & 255] |
-           ((UInt32)SubstTable[(int)(t >> 8) & 255] << 8) |
-           ((UInt32)SubstTable[(int)(t >> 16) & 255] << 16) |
-           ((UInt32)SubstTable[(int)(t >> 24) & 255] << 24);
+    return (UInt32)SubstTable[(unsigned)t & 255]
+        | ((UInt32)SubstTable[(unsigned)(t >> 8) & 255] << 8)
+        | ((UInt32)SubstTable[(unsigned)(t >> 16) & 255] << 16)
+        | ((UInt32)SubstTable[(unsigned)(t >> 24) & 255] << 24);
   }
   void UpdateKeys(const Byte *data);
   void CryptBlock(Byte *buf, bool encrypt);
 public:
   void EncryptBlock(Byte *buf) { CryptBlock(buf, true); }
   void DecryptBlock(Byte *buf) { CryptBlock(buf, false); }
-  void SetPassword(const Byte *password, UInt32 passwordLen);
+  void SetPassword(const Byte *password, unsigned passwordLen);
 };
 
 class CDecoder:
   public ICompressFilter,
-  public ICryptoSetPassword,
-  public CMyUnknownImp
+  public CMyUnknownImp,
+  public CData
 {
-  CData _cipher;
 public:
-  MY_UNKNOWN_IMP1(ICryptoSetPassword)
-
-  STDMETHOD(Init)();
-  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
-  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+  MY_UNKNOWN_IMP
+  INTERFACE_ICompressFilter(;)
 };
 
 }}

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

@@ -0,0 +1,257 @@
+// Crypto/Rar5Aes.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#ifndef _7ZIP_ST
+#include "../../Windows/Synchronization.h"
+#endif
+
+#include "Rar5Aes.h"
+
+namespace NCrypto {
+namespace NRar5 {
+
+static const unsigned kNumIterationsLog_Max = 24;
+
+static const unsigned kPswCheckCsumSize = 4;
+static const unsigned kCheckSize = kPswCheckSize + kPswCheckCsumSize;
+
+CKey::CKey():
+    _needCalc(true),
+    _numIterationsLog(0)
+{
+  for (unsigned i = 0; i < sizeof(_salt); i++)
+    _salt[i] = 0;
+}
+
+CDecoder::CDecoder(): CAesCbcDecoder(kAesKeySize) {}
+
+static unsigned ReadVarInt(const Byte *p, unsigned maxSize, UInt64 *val)
+{
+  unsigned i;
+  *val = 0;
+
+  for (i = 0; i < maxSize;)
+  {
+    Byte b = p[i];
+    if (i < 10)
+      *val |= (UInt64)(b & 0x7F) << (7 * i++);
+    if ((b & 0x80) == 0)
+      return i;
+  }
+  return 0;
+}
+
+HRESULT CDecoder::SetDecoderProps(const Byte *p, unsigned size, bool includeIV, bool isService)
+{
+  UInt64 Version;
+  
+  unsigned num = ReadVarInt(p, size, &Version);
+  if (num == 0)
+    return E_NOTIMPL;
+  p += num;
+  size -= num;
+
+  if (Version != 0)
+    return E_NOTIMPL;
+  
+  num = ReadVarInt(p, size, &Flags);
+  if (num == 0)
+    return E_NOTIMPL;
+  p += num;
+  size -= num;
+
+  bool isCheck = IsThereCheck();
+  if (size != 1 + kSaltSize + (includeIV ? AES_BLOCK_SIZE : 0) + (unsigned)(isCheck ? kCheckSize : 0))
+    return E_NOTIMPL;
+
+  if (_numIterationsLog != p[0])
+  {
+    _numIterationsLog = p[0];
+    _needCalc = true;
+  }
+
+  p++;
+    
+  if (memcmp(_salt, p, kSaltSize) != 0)
+  {
+    memcpy(_salt, p, kSaltSize);
+    _needCalc = true;
+  }
+  
+  p += kSaltSize;
+  
+  if (includeIV)
+  {
+    memcpy(_iv, p, AES_BLOCK_SIZE);
+    p += AES_BLOCK_SIZE;
+  }
+  
+  _canCheck = true;
+  
+  if (isCheck)
+  {
+    memcpy(_check, p, kPswCheckSize);
+    CSha256 sha;
+    Byte digest[SHA256_DIGEST_SIZE];
+    Sha256_Init(&sha);
+    Sha256_Update(&sha, _check, kPswCheckSize);
+    Sha256_Final(&sha, digest);
+    _canCheck = (memcmp(digest, p + kPswCheckSize, kPswCheckCsumSize) == 0);
+    if (_canCheck && isService)
+    {
+      // There was bug in RAR 5.21- : PswCheck field in service records ("QO") contained zeros.
+      // so we disable password checking for such bad records.
+      _canCheck = false;
+      for (unsigned i = 0; i < kPswCheckSize; i++)
+        if (p[i] != 0)
+        {
+          _canCheck = true;
+          break;
+        }
+    }
+  }
+
+  return (_numIterationsLog <= kNumIterationsLog_Max ? S_OK : E_NOTIMPL);
+}
+
+
+void CDecoder::SetPassword(const Byte *data, size_t size)
+{
+  if (size != _password.Size() || memcmp(data, _password, size) != 0)
+  {
+    _needCalc = true;
+    _password.CopyFrom(data, size);
+  }
+}
+
+
+STDMETHODIMP CDecoder::Init()
+{
+  CalcKey_and_CheckPassword();
+  RINOK(SetKey(_key, kAesKeySize));
+  RINOK(SetInitVector(_iv, AES_BLOCK_SIZE));
+  return CAesCbcCoder::Init();
+}
+
+
+UInt32 CDecoder::Hmac_Convert_Crc32(UInt32 crc) const
+{
+  NSha256::CHmac ctx;
+  ctx.SetKey(_hashKey, NSha256::kDigestSize);
+  Byte v[4];
+  SetUi32(v, crc);
+  ctx.Update(v, 4);
+  Byte h[NSha256::kDigestSize];
+  ctx.Final(h);
+  crc = 0;
+  for (unsigned i = 0; i < NSha256::kDigestSize; i++)
+    crc ^= (UInt32)h[i] << ((i & 3) * 8);
+  return crc;
+};
+
+
+void CDecoder::Hmac_Convert_32Bytes(Byte *data) const
+{
+  NSha256::CHmac ctx;
+  ctx.SetKey(_hashKey, NSha256::kDigestSize);
+  ctx.Update(data, NSha256::kDigestSize);
+  ctx.Final(data);
+};
+
+
+#ifndef _7ZIP_ST
+  static CKey g_Key;
+  static NWindows::NSynchronization::CCriticalSection g_GlobalKeyCacheCriticalSection;
+  #define MT_LOCK NWindows::NSynchronization::CCriticalSectionLock lock(g_GlobalKeyCacheCriticalSection);
+#else
+  #define MT_LOCK
+#endif
+
+bool CDecoder::CalcKey_and_CheckPassword()
+{
+  if (_needCalc)
+  {
+    {
+      MT_LOCK
+      if (!g_Key._needCalc && IsKeyEqualTo(g_Key))
+      {
+        CopyCalcedKeysFrom(g_Key);
+        _needCalc = false;
+      }
+    }
+    
+    if (_needCalc)
+    {
+      Byte pswCheck[SHA256_DIGEST_SIZE];
+
+      {
+        // Pbkdf HMAC-SHA-256
+
+        NSha256::CHmac baseCtx;
+        baseCtx.SetKey(_password, _password.Size());
+        
+        NSha256::CHmac ctx = baseCtx;
+        ctx.Update(_salt, sizeof(_salt));
+        
+        Byte u[NSha256::kDigestSize];
+        Byte key[NSha256::kDigestSize];
+        
+        u[0] = 0;
+        u[1] = 0;
+        u[2] = 0;
+        u[3] = 1;
+        
+        ctx.Update(u, 4);
+        ctx.Final(u);
+        
+        memcpy(key, u, NSha256::kDigestSize);
+        
+        UInt32 numIterations = ((UInt32)1 << _numIterationsLog) - 1;
+        
+        for (unsigned i = 0; i < 3; i++)
+        {
+          UInt32 j = numIterations;
+          
+          for (; j != 0; j--)
+          {
+            ctx = baseCtx;
+            ctx.Update(u, NSha256::kDigestSize);
+            ctx.Final(u);
+            for (unsigned s = 0; s < NSha256::kDigestSize; s++)
+              key[s] ^= u[s];
+          }
+          
+          // RAR uses additional iterations for additional keys
+          memcpy((i == 0 ? _key : (i == 1 ? _hashKey : pswCheck)), key, NSha256::kDigestSize);
+          numIterations = 16;
+        }
+      }
+
+      {
+        unsigned i;
+       
+        for (i = 0; i < kPswCheckSize; i++)
+          _check_Calced[i] = pswCheck[i];
+      
+        for (i = kPswCheckSize; i < SHA256_DIGEST_SIZE; i++)
+          _check_Calced[i & (kPswCheckSize - 1)] ^= pswCheck[i];
+      }
+
+      _needCalc = false;
+      
+      {
+        MT_LOCK
+        g_Key = *this;
+      }
+    }
+  }
+  
+  if (IsThereCheck() && _canCheck)
+    return (memcmp(_check_Calced, _check, kPswCheckSize) == 0);
+  return true;
+}
+
+}}

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

@@ -0,0 +1,84 @@
+// Crypto/Rar5Aes.h
+
+#ifndef __CRYPTO_RAR5_AES_H
+#define __CRYPTO_RAR5_AES_H
+
+#include "../../../C/Aes.h"
+
+#include "../../Common/MyBuffer.h"
+
+#include "HmacSha256.h"
+#include "MyAes.h"
+
+namespace NCrypto {
+namespace NRar5 {
+
+const unsigned kSaltSize = 16;
+const unsigned kPswCheckSize = 8;
+const unsigned kAesKeySize = 32;
+
+namespace NCryptoFlags
+{
+  const unsigned kPswCheck = 1 << 0;
+  const unsigned kUseMAC   = 1 << 1;
+}
+
+struct CKey
+{
+  bool _needCalc;
+
+  unsigned _numIterationsLog;
+  Byte _salt[kSaltSize];
+  CByteBuffer _password;
+  
+  Byte _key[kAesKeySize];
+  Byte _check_Calced[kPswCheckSize];
+  Byte _hashKey[SHA256_DIGEST_SIZE];
+
+  void CopyCalcedKeysFrom(const CKey &k)
+  {
+    memcpy(_key, k._key, sizeof(_key));
+    memcpy(_check_Calced, k._check_Calced, sizeof(_check_Calced));
+    memcpy(_hashKey, k._hashKey, sizeof(_hashKey));
+  }
+
+  bool IsKeyEqualTo(const CKey &key)
+  {
+    return (_numIterationsLog == key._numIterationsLog
+        && memcmp(_salt, key._salt, sizeof(_salt)) == 0
+        && _password == key._password);
+  }
+  
+  CKey();
+};
+
+
+class CDecoder:
+  public CAesCbcDecoder,
+  public CKey
+{
+  Byte _check[kPswCheckSize];
+  bool _canCheck;
+  UInt64 Flags;
+
+  bool IsThereCheck() const { return ((Flags & NCryptoFlags::kPswCheck) != 0); }
+public:
+  Byte _iv[AES_BLOCK_SIZE];
+  
+  CDecoder();
+
+  STDMETHOD(Init)();
+
+  void SetPassword(const Byte *data, size_t size);
+  HRESULT SetDecoderProps(const Byte *data, unsigned size, bool includeIV, bool isService);
+
+  bool CalcKey_and_CheckPassword();
+
+  bool UseMAC() const { return (Flags & NCryptoFlags::kUseMAC) != 0; }
+  UInt32 Hmac_Convert_Crc32(UInt32 crc) const;
+  void Hmac_Convert_32Bytes(Byte *data) const;
+};
+
+}}
+
+#endif

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

@@ -1,34 +1,38 @@
 // Crypto/RarAes.cpp
-// Note: you must include MyAes.cpp to project to initialize AES tables
 
 #include "StdAfx.h"
 
 #include "RarAes.h"
-#include "Sha1.h"
+#include "Sha1Cls.h"
 
 namespace NCrypto {
-namespace NRar29 {
+namespace NRar3 {
 
 CDecoder::CDecoder():
-  _thereIsSalt(false),
-  _needCalculate(true),
-  _rar350Mode(false)
+    CAesCbcDecoder(kAesKeySize),
+    _thereIsSalt(false),
+    _needCalc(true)
+    // _rar350Mode(false)
 {
-  for (int i = 0; i < sizeof(_salt); i++)
+  for (unsigned i = 0; i < sizeof(_salt); i++)
     _salt[i] = 0;
 }
 
-STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
+HRESULT CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
 {
-  bool thereIsSaltPrev = _thereIsSalt;
+  bool prev = _thereIsSalt;
   _thereIsSalt = false;
   if (size == 0)
+  {
+    if (!_needCalc && prev)
+      _needCalc = true;
     return S_OK;
+  }
   if (size < 8)
     return E_INVALIDARG;
   _thereIsSalt = true;
   bool same = false;
-  if (_thereIsSalt == thereIsSaltPrev)
+  if (_thereIsSalt == prev)
   {
     same = true;
     if (_thereIsSalt)
@@ -43,92 +47,87 @@ STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
   }
   for (unsigned i = 0; i < sizeof(_salt); i++)
     _salt[i] = data[i];
-  if (!_needCalculate && !same)
-    _needCalculate = true;
+  if (!_needCalc && !same)
+    _needCalc = true;
   return S_OK;
 }
 
-static const unsigned kMaxPasswordLength = 127 * 2;
+static const unsigned kPasswordLen_Bytes_MAX = 127 * 2;
 
-STDMETHODIMP CDecoder::CryptoSetPassword(const Byte *data, UInt32 size)
+void CDecoder::SetPassword(const Byte *data, unsigned size)
 {
-  if (size > kMaxPasswordLength)
-    size = kMaxPasswordLength;
+  if (size > kPasswordLen_Bytes_MAX)
+    size = kPasswordLen_Bytes_MAX;
   bool same = false;
-  if (size == buffer.GetCapacity())
+  if (size == _password.Size())
   {
     same = true;
     for (UInt32 i = 0; i < size; i++)
-      if (data[i] != buffer[i])
+      if (data[i] != _password[i])
       {
         same = false;
         break;
       }
   }
-  if (!_needCalculate && !same)
-    _needCalculate = true;
-  buffer.SetCapacity(size);
-  memcpy(buffer, data, size);
-  return S_OK;
+  if (!_needCalc && !same)
+    _needCalc = true;
+  _password.CopyFrom(data, (size_t)size);
 }
 
 STDMETHODIMP CDecoder::Init()
 {
-  Calculate();
-  SetKey(aesKey, kRarAesKeySize);
-  AesCbc_Init(_aes + _offset, _aesInit);
-  return S_OK;
+  CalcKey();
+  RINOK(SetKey(_key, kAesKeySize));
+  RINOK(SetInitVector(_iv, AES_BLOCK_SIZE));
+  return CAesCbcCoder::Init();
 }
 
-void CDecoder::Calculate()
+void CDecoder::CalcKey()
 {
-  if (_needCalculate)
-  {
-    const unsigned kSaltSize = 8;
-    
-    Byte rawPassword[kMaxPasswordLength + kSaltSize];
-    
-    memcpy(rawPassword, buffer, buffer.GetCapacity());
-    
-    size_t rawLength = buffer.GetCapacity();
-    
-    if (_thereIsSalt)
-    {
-      memcpy(rawPassword + rawLength, _salt, kSaltSize);
-      rawLength += kSaltSize;
-    }
-    
-    NSha1::CContext sha;
-    sha.Init();
+  if (!_needCalc)
+    return;
 
-    // rar reverts hash for sha.
-    const unsigned kNumRounds = (1 << 18);
-    unsigned i;
-    for (i = 0; i < kNumRounds; i++)
+  const unsigned kSaltSize = 8;
+  
+  Byte buf[kPasswordLen_Bytes_MAX + kSaltSize];
+  
+  if (_password.Size() != 0)
+    memcpy(buf, _password, _password.Size());
+  
+  size_t rawSize = _password.Size();
+  
+  if (_thereIsSalt)
+  {
+    memcpy(buf + rawSize, _salt, kSaltSize);
+    rawSize += kSaltSize;
+  }
+  
+  NSha1::CContext sha;
+  sha.Init();
+  
+  Byte digest[NSha1::kDigestSize];
+  // rar reverts hash for sha.
+  const UInt32 kNumRounds = ((UInt32)1 << 18);
+  UInt32 i;
+  for (i = 0; i < kNumRounds; i++)
+  {
+    sha.UpdateRar(buf, rawSize /* , _rar350Mode */);
+    Byte pswNum[3] = { (Byte)i, (Byte)(i >> 8), (Byte)(i >> 16) };
+    sha.UpdateRar(pswNum, 3 /* , _rar350Mode */);
+    if (i % (kNumRounds / 16) == 0)
     {
-      sha.UpdateRar(rawPassword, rawLength, _rar350Mode);
-      Byte pswNum[3] = { (Byte)i, (Byte)(i >> 8), (Byte)(i >> 16) };
-      sha.UpdateRar(pswNum, 3, _rar350Mode);
-      if (i % (kNumRounds / 16) == 0)
-      {
-        NSha1::CContext shaTemp = sha;
-        Byte digest[NSha1::kDigestSize];
-        shaTemp.Final(digest);
-        _aesInit[i / (kNumRounds / 16)] = (Byte)digest[4 * 4 + 3];
-      }
+      NSha1::CContext shaTemp = sha;
+      shaTemp.Final(digest);
+      _iv[i / (kNumRounds / 16)] = (Byte)digest[4 * 4 + 3];
     }
-    /*
-    // it's test message for sha
-    const char *message = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
-    sha.Update((const Byte *)message, strlen(message));
-    */
-    Byte digest[20];
-    sha.Final(digest);
-    for (i = 0; i < 4; i++)
-      for (unsigned j = 0; j < 4; j++)
-        aesKey[i * 4 + j] = (digest[i * 4 + 3 - j]);
   }
-  _needCalculate = false;
+  
+  sha.Final(digest);
+  for (i = 0; i < 4; i++)
+    for (unsigned j = 0; j < 4; j++)
+      _key[i * 4 + j] = (digest[i * 4 + 3 - j]);
+    
+  _needCalc = false;
 }
 
 }}

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

@@ -5,41 +5,46 @@
 
 #include "../../../C/Aes.h"
 
-#include "Common/Buffer.h"
+#include "../../Common/MyBuffer.h"
 
 #include "../IPassword.h"
 
 #include "MyAes.h"
 
 namespace NCrypto {
-namespace NRar29 {
+namespace NRar3 {
 
-const UInt32 kRarAesKeySize = 16;
+const unsigned kAesKeySize = 16;
 
 class CDecoder:
-  public CAesCbcDecoder,
-  public ICompressSetDecoderProperties2,
-  public ICryptoSetPassword
+  public CAesCbcDecoder
+  // public ICompressSetDecoderProperties2,
+  // public ICryptoSetPassword
 {
   Byte _salt[8];
   bool _thereIsSalt;
-  CByteBuffer buffer;
-  Byte aesKey[kRarAesKeySize];
-  Byte _aesInit[AES_BLOCK_SIZE];
-  bool _needCalculate;
-  bool _rar350Mode;
-
-  void Calculate();
+  bool _needCalc;
+  // bool _rar350Mode;
+  
+  CByteBuffer _password;
+  
+  Byte _key[kAesKeySize];
+  Byte _iv[AES_BLOCK_SIZE];
+
+  void CalcKey();
 public:
-  MY_UNKNOWN_IMP2(
-    ICryptoSetPassword,
-    ICompressSetDecoderProperties2)
+  /*
+  MY_UNKNOWN_IMP1(
+    ICryptoSetPassword
+    // ICompressSetDecoderProperties2
+  */
   STDMETHOD(Init)();
-  STDMETHOD(CryptoSetPassword)(const Byte *aData, UInt32 aSize);
-  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
+  
+  void SetPassword(const Byte *data, unsigned size);
+  HRESULT SetDecoderProperties2(const Byte *data, UInt32 size);
 
   CDecoder();
-  void SetRar350Mode(bool rar350Mode) { _rar350Mode = rar350Mode; }
+  // void SetRar350Mode(bool rar350Mode) { _rar350Mode = rar350Mode; }
 };
 
 }}