seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -0,0 +1,51 @@
+// Crypto/Sha1.h
+
+#ifndef __CRYPTO_SHA1_H
+#define __CRYPTO_SHA1_H
+
+#include "../../../C/Sha1.h"
+
+namespace NCrypto {
+namespace NSha1 {
+
+const unsigned kNumBlockWords = SHA1_NUM_BLOCK_WORDS;
+const unsigned kNumDigestWords = SHA1_NUM_DIGEST_WORDS;
+
+const unsigned kBlockSize = SHA1_BLOCK_SIZE;
+const unsigned kDigestSize = SHA1_DIGEST_SIZE;
+
+class CContextBase
+{
+protected:
+  CSha1 _s;
+ 
+public:
+  void Init() throw() { Sha1_Init(&_s); }
+  void GetBlockDigest(const UInt32 *blockData, UInt32 *destDigest) throw() { Sha1_GetBlockDigest(&_s, blockData, destDigest); }
+};
+
+class CContext: public CContextBase
+{
+public:
+  void Update(const Byte *data, size_t size) throw() { Sha1_Update(&_s, data, size); }
+  void UpdateRar(Byte *data, size_t size /* , bool rar350Mode */) throw() { Sha1_Update_Rar(&_s, data, size /* , rar350Mode ? 1 : 0 */); }
+  void Final(Byte *digest) throw() { Sha1_Final(&_s, digest); }
+};
+
+class CContext32: public CContextBase
+{
+public:
+  void Update(const UInt32 *data, size_t size) throw() { Sha1_32_Update(&_s, data, size); }
+  void Final(UInt32 *digest) throw() { Sha1_32_Final(&_s, digest); }
+  
+  /* PrepareBlock can be used only when size <= 13. size in Words
+     _buffer must be empty (_count & 0xF) == 0) */
+  void PrepareBlock(UInt32 *block, unsigned size) const throw()
+  {
+    Sha1_32_PrepareBlock(&_s, block, size);
+  }
+};
+
+}}
+
+#endif

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

@@ -1,21 +1,22 @@
 // Crypto/WzAes.cpp
 /*
 This code implements Brian Gladman's scheme
-specified in password Based File Encryption Utility.
+specified in "A Password Based File Encryption Utility".
 
 Note: you must include MyAes.cpp to project to initialize AES tables
 */
 
 #include "StdAfx.h"
 
-#include "../Common/StreamObjects.h"
+#include "../../../C/CpuArch.h"
+
 #include "../Common/StreamUtils.h"
 
 #include "Pbkdf2HmacSha1.h"
 #include "RandGen.h"
 #include "WzAes.h"
 
-// define it if you don't want to use speed-optimized version of Pbkdf2HmacSha1
+// define it if you don't want to use speed-optimized version of NSha1::Pbkdf2Hmac
 // #define _NO_WZAES_OPTIMIZATIONS
 
 namespace NCrypto {
@@ -27,76 +28,78 @@ static const UInt32 kNumKeyGenIterations = 1000;
 
 STDMETHODIMP CBaseCoder::CryptoSetPassword(const Byte *data, UInt32 size)
 {
-  if(size > kPasswordSizeMax)
+  if (size > kPasswordSizeMax)
     return E_INVALIDARG;
-  _key.Password.SetCapacity(size);
-  memcpy(_key.Password, data, size);
+  _key.Password.CopyFrom(data, (size_t)size);
   return S_OK;
 }
 
-#ifndef _NO_WZAES_OPTIMIZATIONS
-
-static void BytesToBeUInt32s(const Byte *src, UInt32 *dest, unsigned destSize)
+void CBaseCoder::Init2()
 {
-  for (unsigned i = 0; i < destSize; i++)
-      dest[i] =
-          ((UInt32)(src[i * 4 + 0]) << 24) |
-          ((UInt32)(src[i * 4 + 1]) << 16) |
-          ((UInt32)(src[i * 4 + 2]) <<  8) |
-          ((UInt32)(src[i * 4 + 3]));
-}
+  const unsigned dkSizeMax32 = (2 * kAesKeySizeMax + kPwdVerifSize + 3) / 4;
+  Byte dk[dkSizeMax32 * 4];
 
-#endif
-
-STDMETHODIMP CBaseCoder::Init()
-{
-  UInt32 keySize = _key.GetKeySize();
-  UInt32 keysTotalSize = 2 * keySize + kPwdVerifCodeSize;
-  Byte buf[2 * kAesKeySizeMax + kPwdVerifCodeSize];
+  const unsigned keySize = _key.GetKeySize();
+  const unsigned dkSize = 2 * keySize + kPwdVerifSize;
   
   // for (unsigned ii = 0; ii < 1000; ii++)
   {
     #ifdef _NO_WZAES_OPTIMIZATIONS
 
     NSha1::Pbkdf2Hmac(
-      _key.Password, _key.Password.GetCapacity(),
-      _key.Salt, _key.GetSaltSize(),
-      kNumKeyGenIterations,
-      buf, keysTotalSize);
+        _key.Password, _key.Password.Size(),
+        _key.Salt, _key.GetSaltSize(),
+        kNumKeyGenIterations,
+        dk, dkSize);
 
     #else
 
-    UInt32 buf32[(2 * kAesKeySizeMax + kPwdVerifCodeSize + 3) / 4];
-    UInt32 key32SizeTotal = (keysTotalSize + 3) / 4;
-    UInt32 salt[kSaltSizeMax * 4];
-    UInt32 saltSizeInWords = _key.GetSaltSize() / 4;
-    BytesToBeUInt32s(_key.Salt, salt, saltSizeInWords);
+    UInt32 dk32[dkSizeMax32];
+    const unsigned dkSize32 = (dkSize + 3) / 4;
+    UInt32 salt[kSaltSizeMax / 4];
+    unsigned numSaltWords = _key.GetNumSaltWords();
+    
+    for (unsigned i = 0; i < numSaltWords; i++)
+    {
+      const Byte *src = _key.Salt + i * 4;
+      salt[i] = GetBe32(src);
+    }
+
     NSha1::Pbkdf2Hmac32(
-      _key.Password, _key.Password.GetCapacity(),
-      salt, saltSizeInWords,
-      kNumKeyGenIterations,
-      buf32, key32SizeTotal);
-    for (UInt32 j = 0; j < keysTotalSize; j++)
-      buf[j] = (Byte)(buf32[j / 4] >> (24 - 8 * (j & 3)));
+        _key.Password, _key.Password.Size(),
+        salt, numSaltWords,
+        kNumKeyGenIterations,
+        dk32, dkSize32);
+    
+    /*
+    for (unsigned j = 0; j < dkSize; j++)
+      dk[j] = (Byte)(dk32[j / 4] >> (24 - 8 * (j & 3)));
+    */
+    for (unsigned j = 0; j < dkSize32; j++)
+      SetBe32(dk + j * 4, dk32[j]);
     
     #endif
   }
 
-  _hmac.SetKey(buf + keySize, keySize);
-  memcpy(_key.PwdVerifComputed, buf + 2 * keySize, kPwdVerifCodeSize);
+  _hmac.SetKey(dk + keySize, keySize);
+  memcpy(_key.PwdVerifComputed, dk + 2 * keySize, kPwdVerifSize);
 
+  Aes_SetKey_Enc(_aes.aes + _aes.offset + 8, dk, keySize);
   AesCtr2_Init(&_aes);
-  Aes_SetKey_Enc(_aes.aes + _aes.offset + 8, buf, keySize);
+}
+
+STDMETHODIMP CBaseCoder::Init()
+{
   return S_OK;
 }
 
 HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream)
 {
-  UInt32 saltSize = _key.GetSaltSize();
+  unsigned saltSize = _key.GetSaltSize();
   g_RandomGenerator.Generate(_key.Salt, saltSize);
-  Init();
+  Init2();
   RINOK(WriteStream(outStream, _key.Salt, saltSize));
-  return WriteStream(outStream, _key.PwdVerifComputed, kPwdVerifCodeSize);
+  return WriteStream(outStream, _key.PwdVerifComputed, kPwdVerifSize);
 }
 
 HRESULT CEncoder::WriteFooter(ISequentialOutStream *outStream)
@@ -106,6 +109,7 @@ HRESULT CEncoder::WriteFooter(ISequentialOutStream *outStream)
   return WriteStream(outStream, mac, kMacSize);
 }
 
+/*
 STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
 {
   if (size != 1)
@@ -113,32 +117,34 @@ STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
   _key.Init();
   return SetKeyMode(data[0]) ? S_OK : E_INVALIDARG;
 }
+*/
 
 HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream)
 {
-  UInt32 saltSize = _key.GetSaltSize();
-  UInt32 extraSize = saltSize + kPwdVerifCodeSize;
-  Byte temp[kSaltSizeMax + kPwdVerifCodeSize];
+  unsigned saltSize = _key.GetSaltSize();
+  unsigned extraSize = saltSize + kPwdVerifSize;
+  Byte temp[kSaltSizeMax + kPwdVerifSize];
   RINOK(ReadStream_FAIL(inStream, temp, extraSize));
-  UInt32 i;
+  unsigned i;
   for (i = 0; i < saltSize; i++)
     _key.Salt[i] = temp[i];
-  for (i = 0; i < kPwdVerifCodeSize; i++)
+  for (i = 0; i < kPwdVerifSize; i++)
     _pwdVerifFromArchive[i] = temp[saltSize + i];
   return S_OK;
 }
 
-static bool CompareArrays(const Byte *p1, const Byte *p2, UInt32 size)
+static inline bool CompareArrays(const Byte *p1, const Byte *p2, unsigned size)
 {
-  for (UInt32 i = 0; i < size; i++)
+  for (unsigned i = 0; i < size; i++)
     if (p1[i] != p2[i])
       return false;
   return true;
 }
 
-bool CDecoder::CheckPasswordVerifyCode()
+bool CDecoder::Init_and_CheckPassword()
 {
-  return CompareArrays(_key.PwdVerifComputed, _pwdVerifFromArchive, kPwdVerifCodeSize);
+  Init2();
+  return CompareArrays(_key.PwdVerifComputed, _pwdVerifFromArchive, kPwdVerifSize);
 }
 
 HRESULT CDecoder::CheckMac(ISequentialInStream *inStream, bool &isOK)
@@ -166,12 +172,15 @@ void AesCtr2_Init(CAesCtr2 *p)
   p->pos = AES_BLOCK_SIZE;
 }
 
+/* (size != 16 * N) is allowed only for last call */
+
 void AesCtr2_Code(CAesCtr2 *p, Byte *data, SizeT size)
 {
   unsigned pos = p->pos;
   UInt32 *buf32 = p->aes + p->offset;
   if (size == 0)
     return;
+  
   if (pos != AES_BLOCK_SIZE)
   {
     const Byte *buf = (const Byte *)buf32;
@@ -179,6 +188,7 @@ void AesCtr2_Code(CAesCtr2 *p, Byte *data, SizeT size)
       *data++ ^= buf[pos++];
     while (--size != 0 && pos != AES_BLOCK_SIZE);
   }
+  
   if (size >= 16)
   {
     SizeT size2 = size >> 4;
@@ -188,6 +198,7 @@ void AesCtr2_Code(CAesCtr2 *p, Byte *data, SizeT size)
     size -= size2;
     pos = AES_BLOCK_SIZE;
   }
+  
   if (size != 0)
   {
     unsigned j;
@@ -199,11 +210,14 @@ void AesCtr2_Code(CAesCtr2 *p, Byte *data, SizeT size)
     pos = 0;
     do
       *data++ ^= buf[pos++];
-    while (--size != 0 && pos != AES_BLOCK_SIZE);
+    while (--size != 0);
   }
+  
   p->pos = pos;
 }
 
+/* (size != 16 * N) is allowed only for last Filter() call */
+
 STDMETHODIMP_(UInt32) CEncoder::Filter(Byte *data, UInt32 size)
 {
   AesCtr2_Code(&_aes, data, size);

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

@@ -1,7 +1,7 @@
 // Crypto/WzAes.h
 /*
 This code implements Brian Gladman's scheme
-specified in password Based File Encryption Utility:
+specified in "A Password Based File Encryption Utility":
   - AES encryption (128,192,256-bit) in Counter (CTR) mode.
   - HMAC-SHA1 authentication for encrypted data (10 bytes)
   - Keys are derived by PPKDF2(RFC2898)-HMAC-SHA1 from ASCII password and
@@ -14,9 +14,8 @@ specified in password Based File Encryption Utility:
 
 #include "../../../C/Aes.h"
 
-#include "Common/Buffer.h"
-#include "Common/MyCom.h"
-#include "Common/MyVector.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
 
 #include "../ICoder.h"
 #include "../IPassword.h"
@@ -26,13 +25,24 @@ specified in password Based File Encryption Utility:
 namespace NCrypto {
 namespace NWzAes {
 
-const unsigned kSaltSizeMax = 16;
-const unsigned kMacSize = 10;
+/* ICompressFilter::Init() does nothing for this filter.
+
+  Call to init:
+    Encoder:
+      CryptoSetPassword();
+      WriteHeader();
+    Decoder:
+      [CryptoSetPassword();]
+      ReadHeader();
+      [CryptoSetPassword();] Init_and_CheckPassword();
+      [CryptoSetPassword();] Init_and_CheckPassword();
+*/
 
 const UInt32 kPasswordSizeMax = 99; // 128;
 
-// Password Verification Code Size
-const unsigned kPwdVerifCodeSize = 2;
+const unsigned kSaltSizeMax = 16;
+const unsigned kPwdVerifSize = 2;
+const unsigned kMacSize = 10;
 
 enum EKeySizeMode
 {
@@ -41,20 +51,19 @@ enum EKeySizeMode
   kKeySizeMode_AES256 = 3
 };
 
-class CKeyInfo
+struct CKeyInfo
 {
-public:
   EKeySizeMode KeySizeMode;
   Byte Salt[kSaltSizeMax];
-  Byte PwdVerifComputed[kPwdVerifCodeSize];
+  Byte PwdVerifComputed[kPwdVerifSize];
 
   CByteBuffer Password;
 
-  UInt32 GetKeySize() const  { return (8 * (KeySizeMode & 3) + 8); }
-  UInt32 GetSaltSize() const { return (4 * (KeySizeMode & 3) + 4); }
+  unsigned GetKeySize()  const { return (8 * KeySizeMode + 8); }
+  unsigned GetSaltSize() const { return (4 * KeySizeMode + 4); }
+  unsigned GetNumSaltWords() const { return (KeySizeMode + 1); }
 
-  CKeyInfo() { Init(); }
-  void Init() { KeySizeMode = kKeySizeMode_AES256; }
+  CKeyInfo(): KeySizeMode(kKeySizeMode_AES256) {}
 };
 
 struct CAesCtr2
@@ -76,16 +85,19 @@ class CBaseCoder:
 protected:
   CKeyInfo _key;
   NSha1::CHmac _hmac;
-  Byte _pwdVerifFromArchive[kPwdVerifCodeSize];
   CAesCtr2 _aes;
 
+  void Init2();
 public:
+  MY_UNKNOWN_IMP1(ICryptoSetPassword)
+
+  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+
   STDMETHOD(Init)();
-  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) = 0;
   
-  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+  unsigned GetHeaderSize() const { return _key.GetSaltSize() + kPwdVerifSize; }
+  unsigned GetAddPackSize() const { return GetHeaderSize() + kMacSize; }
 
-  UInt32 GetHeaderSize() const { return _key.GetSaltSize() + kPwdVerifCodeSize; }
   bool SetKeyMode(unsigned mode)
   {
     if (mode < kKeySizeMode_AES128 || mode > kKeySizeMode_AES256)
@@ -99,24 +111,22 @@ class CEncoder:
   public CBaseCoder
 {
 public:
-  MY_UNKNOWN_IMP1(ICryptoSetPassword)
   STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
   HRESULT WriteHeader(ISequentialOutStream *outStream);
   HRESULT WriteFooter(ISequentialOutStream *outStream);
 };
 
 class CDecoder:
-  public CBaseCoder,
-  public ICompressSetDecoderProperties2
+  public CBaseCoder
+  // public ICompressSetDecoderProperties2
 {
+  Byte _pwdVerifFromArchive[kPwdVerifSize];
 public:
-  MY_UNKNOWN_IMP2(
-      ICryptoSetPassword,
-      ICompressSetDecoderProperties2)
+  // ICompressSetDecoderProperties2
+  // STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
   STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
-  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
   HRESULT ReadHeader(ISequentialInStream *inStream);
-  bool CheckPasswordVerifyCode();
+  bool Init_and_CheckPassword();
   HRESULT CheckMac(ISequentialInStream *inStream, bool &isOK);
 };
 

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

@@ -12,23 +12,27 @@
 namespace NCrypto {
 namespace NZip {
 
-void CCipher::UpdateKeys(Byte b)
-{
-  Keys[0] = CRC_UPDATE_BYTE(Keys[0], b);
-  Keys[1] = (Keys[1] + (Keys[0] & 0xFF)) * 0x8088405 + 1;
-  Keys[2] = CRC_UPDATE_BYTE(Keys[2], (Byte)(Keys[1] >> 24));
-}
+#define UPDATE_KEYS(b) { \
+  key0 = CRC_UPDATE_BYTE(key0, b); \
+  key1 = (key1 + (key0 & 0xFF)) * 0x8088405 + 1; \
+  key2 = CRC_UPDATE_BYTE(key2, (Byte)(key1 >> 24)); } \
+
+#define DECRYPT_BYTE_1 UInt32 temp = key2 | 2;
+#define DECRYPT_BYTE_2 ((Byte)((temp * (temp ^ 1)) >> 8))
 
-STDMETHODIMP CCipher::CryptoSetPassword(const Byte *password, UInt32 passwordLen)
+STDMETHODIMP CCipher::CryptoSetPassword(const Byte *data, UInt32 size)
 {
-  Keys[0] = 0x12345678;
-  Keys[1] = 0x23456789;
-  Keys[2] = 0x34567890;
-  UInt32 i;
-  for (i = 0; i < passwordLen; i++)
-    UpdateKeys(password[i]);
-  for (i = 0; i < 3; i++)
-    Keys2[i] = Keys[i];
+  UInt32 key0 = 0x12345678;
+  UInt32 key1 = 0x23456789;
+  UInt32 key2 = 0x34567890;
+  
+  for (UInt32 i = 0; i < size; i++)
+    UPDATE_KEYS(data[i]);
+
+  KeyMem0 = key0;
+  KeyMem1 = key1;
+  KeyMem2 = key2;
+  
   return S_OK;
 }
 
@@ -37,18 +41,18 @@ STDMETHODIMP CCipher::Init()
   return S_OK;
 }
 
-Byte CCipher::DecryptByteSpec()
-{
-  UInt32 temp = Keys[2] | 2;
-  return (Byte)((temp * (temp ^ 1)) >> 8);
-}
-
-HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream, UInt32 crc)
+HRESULT CEncoder::WriteHeader_Check16(ISequentialOutStream *outStream, UInt16 crc)
 {
   Byte h[kHeaderSize];
-  g_RandomGenerator.Generate(h, kHeaderSize - 2);
-  h[kHeaderSize - 1] = (Byte)(crc >> 24);
-  h[kHeaderSize - 2] = (Byte)(crc >> 16);
+  
+  /* PKZIP before 2.0 used 2 byte CRC check.
+     PKZIP 2.0+ used 1 byte CRC check. It's more secure.
+     We also use 1 byte CRC. */
+
+  g_RandomGenerator.Generate(h, kHeaderSize - 1);
+  // h[kHeaderSize - 2] = (Byte)(crc);
+  h[kHeaderSize - 1] = (Byte)(crc >> 8);
+  
   RestoreKeys();
   Filter(h, kHeaderSize);
   return WriteStream(outStream, h, kHeaderSize);
@@ -56,32 +60,54 @@ HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream, UInt32 crc)
 
 STDMETHODIMP_(UInt32) CEncoder::Filter(Byte *data, UInt32 size)
 {
+  UInt32 key0 = this->Key0;
+  UInt32 key1 = this->Key1;
+  UInt32 key2 = this->Key2;
+
   for (UInt32 i = 0; i < size; i++)
   {
     Byte b = data[i];
-    data[i] = (Byte)(b ^ DecryptByteSpec());;
-    UpdateKeys(b);
+    DECRYPT_BYTE_1
+    data[i] = (Byte)(b ^ DECRYPT_BYTE_2);
+    UPDATE_KEYS(b);
   }
+
+  this->Key0 = key0;
+  this->Key1 = key1;
+  this->Key2 = key2;
+
   return size;
 }
 
 HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream)
 {
-  Byte h[kHeaderSize];
-  RINOK(ReadStream_FAIL(inStream, h, kHeaderSize));
+  return ReadStream_FAIL(inStream, _header, kHeaderSize);
+}
+
+void CDecoder::Init_BeforeDecode()
+{
   RestoreKeys();
-  Filter(h, kHeaderSize);
-  return S_OK;
+  Filter(_header, kHeaderSize);
 }
 
 STDMETHODIMP_(UInt32) CDecoder::Filter(Byte *data, UInt32 size)
 {
+  UInt32 key0 = this->Key0;
+  UInt32 key1 = this->Key1;
+  UInt32 key2 = this->Key2;
+  
   for (UInt32 i = 0; i < size; i++)
   {
-    Byte c = (Byte)(data[i] ^ DecryptByteSpec());
-    UpdateKeys(c);
-    data[i] = c;
+    DECRYPT_BYTE_1
+    Byte b = (Byte)(data[i] ^ DECRYPT_BYTE_2);
+    UPDATE_KEYS(b);
+    data[i] = b;
   }
+  
+  this->Key0 = key0;
+  this->Key1 = key1;
+  this->Key2 = key2;
+  
   return size;
 }
 

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

@@ -3,7 +3,7 @@
 #ifndef __CRYPTO_ZIP_CRYPTO_H
 #define __CRYPTO_ZIP_CRYPTO_H
 
-#include "Common/MyCom.h"
+#include "../../Common/MyCom.h"
 
 #include "../ICoder.h"
 #include "../IPassword.h"
@@ -13,24 +13,41 @@ namespace NZip {
 
 const unsigned kHeaderSize = 12;
 
+/* ICompressFilter::Init() does nothing for this filter.
+  Call to init:
+    Encoder:
+      CryptoSetPassword();
+      WriteHeader();
+    Decoder:
+      [CryptoSetPassword();]
+      ReadHeader();
+      [CryptoSetPassword();] Init_and_GetCrcByte();
+      [CryptoSetPassword();] Init_and_GetCrcByte();
+*/
+
 class CCipher:
   public ICompressFilter,
   public ICryptoSetPassword,
   public CMyUnknownImp
 {
-  UInt32 Keys[3];
-  UInt32 Keys2[3];
-
 protected:
-  void UpdateKeys(Byte b);
-  Byte DecryptByteSpec();
+  UInt32 Key0;
+  UInt32 Key1;
+  UInt32 Key2;
+  
+  UInt32 KeyMem0;
+  UInt32 KeyMem1;
+  UInt32 KeyMem2;
+
   void RestoreKeys()
   {
-    for (int i = 0; i < 3; i++)
-      Keys[i] = Keys2[i];
+    Key0 = KeyMem0;
+    Key1 = KeyMem1;
+    Key2 = KeyMem2;
   }
 
 public:
+  MY_UNKNOWN_IMP1(ICryptoSetPassword)
   STDMETHOD(Init)();
   STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
 };
@@ -38,17 +55,17 @@ public:
 class CEncoder: public CCipher
 {
 public:
-  MY_UNKNOWN_IMP1(ICryptoSetPassword)
   STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
-  HRESULT WriteHeader(ISequentialOutStream *outStream, UInt32 crc);
+  HRESULT WriteHeader_Check16(ISequentialOutStream *outStream, UInt16 crc);
 };
 
 class CDecoder: public CCipher
 {
 public:
-  MY_UNKNOWN_IMP1(ICryptoSetPassword)
+  Byte _header[kHeaderSize];
   STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
   HRESULT ReadHeader(ISequentialInStream *inStream);
+  void Init_BeforeDecode();
 };
 
 }}