seven_zip_ruby_am 1.2.5.1

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

@@ -0,0 +1,125 @@
+// Crypto/WzAes.h
+/*
+This code implements Brian Gladman's scheme
+specified in 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
+    Salt (saltSize = aesKeySize / 2).
+  - 2 bytes contain Password Verifier's Code
+*/
+
+#ifndef __CRYPTO_WZ_AES_H
+#define __CRYPTO_WZ_AES_H
+
+#include "../../../C/Aes.h"
+
+#include "Common/Buffer.h"
+#include "Common/MyCom.h"
+#include "Common/MyVector.h"
+
+#include "../ICoder.h"
+#include "../IPassword.h"
+
+#include "HmacSha1.h"
+
+namespace NCrypto {
+namespace NWzAes {
+
+const unsigned kSaltSizeMax = 16;
+const unsigned kMacSize = 10;
+
+const UInt32 kPasswordSizeMax = 99; // 128;
+
+// Password Verification Code Size
+const unsigned kPwdVerifCodeSize = 2;
+
+enum EKeySizeMode
+{
+  kKeySizeMode_AES128 = 1,
+  kKeySizeMode_AES192 = 2,
+  kKeySizeMode_AES256 = 3
+};
+
+class CKeyInfo
+{
+public:
+  EKeySizeMode KeySizeMode;
+  Byte Salt[kSaltSizeMax];
+  Byte PwdVerifComputed[kPwdVerifCodeSize];
+
+  CByteBuffer Password;
+
+  UInt32 GetKeySize() const  { return (8 * (KeySizeMode & 3) + 8); }
+  UInt32 GetSaltSize() const { return (4 * (KeySizeMode & 3) + 4); }
+
+  CKeyInfo() { Init(); }
+  void Init() { KeySizeMode = kKeySizeMode_AES256; }
+};
+
+struct CAesCtr2
+{
+  unsigned pos;
+  unsigned offset;
+  UInt32 aes[4 + AES_NUM_IVMRK_WORDS + 3];
+  CAesCtr2();
+};
+
+void AesCtr2_Init(CAesCtr2 *p);
+void AesCtr2_Code(CAesCtr2 *p, Byte *data, SizeT size);
+
+class CBaseCoder:
+  public ICompressFilter,
+  public ICryptoSetPassword,
+  public CMyUnknownImp
+{
+protected:
+  CKeyInfo _key;
+  NSha1::CHmac _hmac;
+  Byte _pwdVerifFromArchive[kPwdVerifCodeSize];
+  CAesCtr2 _aes;
+
+public:
+  STDMETHOD(Init)();
+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) = 0;
+  
+  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+
+  UInt32 GetHeaderSize() const { return _key.GetSaltSize() + kPwdVerifCodeSize; }
+  bool SetKeyMode(unsigned mode)
+  {
+    if (mode < kKeySizeMode_AES128 || mode > kKeySizeMode_AES256)
+      return false;
+    _key.KeySizeMode = (EKeySizeMode)mode;
+    return true;
+  }
+};
+
+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:
+  MY_UNKNOWN_IMP2(
+      ICryptoSetPassword,
+      ICompressSetDecoderProperties2)
+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
+  HRESULT ReadHeader(ISequentialInStream *inStream);
+  bool CheckPasswordVerifyCode();
+  HRESULT CheckMac(ISequentialInStream *inStream, bool &isOK);
+};
+
+}}
+
+#endif

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

@@ -0,0 +1,88 @@
+// Crypto/ZipCrypto.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "RandGen.h"
+#include "ZipCrypto.h"
+
+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));
+}
+
+STDMETHODIMP CCipher::CryptoSetPassword(const Byte *password, UInt32 passwordLen)
+{
+  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];
+  return S_OK;
+}
+
+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)
+{
+  Byte h[kHeaderSize];
+  g_RandomGenerator.Generate(h, kHeaderSize - 2);
+  h[kHeaderSize - 1] = (Byte)(crc >> 24);
+  h[kHeaderSize - 2] = (Byte)(crc >> 16);
+  RestoreKeys();
+  Filter(h, kHeaderSize);
+  return WriteStream(outStream, h, kHeaderSize);
+}
+
+STDMETHODIMP_(UInt32) CEncoder::Filter(Byte *data, UInt32 size)
+{
+  for (UInt32 i = 0; i < size; i++)
+  {
+    Byte b = data[i];
+    data[i] = (Byte)(b ^ DecryptByteSpec());;
+    UpdateKeys(b);
+  }
+  return size;
+}
+
+HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream)
+{
+  Byte h[kHeaderSize];
+  RINOK(ReadStream_FAIL(inStream, h, kHeaderSize));
+  RestoreKeys();
+  Filter(h, kHeaderSize);
+  return S_OK;
+}
+
+STDMETHODIMP_(UInt32) CDecoder::Filter(Byte *data, UInt32 size)
+{
+  for (UInt32 i = 0; i < size; i++)
+  {
+    Byte c = (Byte)(data[i] ^ DecryptByteSpec());
+    UpdateKeys(c);
+    data[i] = c;
+  }
+  return size;
+}
+
+}}

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

@@ -0,0 +1,56 @@
+// Crypto/ZipCrypto.h
+
+#ifndef __CRYPTO_ZIP_CRYPTO_H
+#define __CRYPTO_ZIP_CRYPTO_H
+
+#include "Common/MyCom.h"
+
+#include "../ICoder.h"
+#include "../IPassword.h"
+
+namespace NCrypto {
+namespace NZip {
+
+const unsigned kHeaderSize = 12;
+
+class CCipher:
+  public ICompressFilter,
+  public ICryptoSetPassword,
+  public CMyUnknownImp
+{
+  UInt32 Keys[3];
+  UInt32 Keys2[3];
+
+protected:
+  void UpdateKeys(Byte b);
+  Byte DecryptByteSpec();
+  void RestoreKeys()
+  {
+    for (int i = 0; i < 3; i++)
+      Keys[i] = Keys2[i];
+  }
+
+public:
+  STDMETHOD(Init)();
+  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+};
+
+class CEncoder: public CCipher
+{
+public:
+  MY_UNKNOWN_IMP1(ICryptoSetPassword)
+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  HRESULT WriteHeader(ISequentialOutStream *outStream, UInt32 crc);
+};
+
+class CDecoder: public CCipher
+{
+public:
+  MY_UNKNOWN_IMP1(ICryptoSetPassword)
+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  HRESULT ReadHeader(ISequentialInStream *inStream);
+};
+
+}}
+
+#endif

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

@@ -0,0 +1,164 @@
+// Crypto/ZipStrong.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/CpuArch.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "MyAes.h"
+#include "Sha1.h"
+#include "ZipStrong.h"
+
+namespace NCrypto {
+namespace NZipStrong {
+
+static const UInt16 kAES128 = 0x660E;
+
+// DeriveKey* function is similar to CryptDeriveKey() from Windows.
+// But MSDN tells that we need such scheme only if
+// "the required key length is longer than the hash value"
+// but ZipStrong uses it always.
+
+static void DeriveKey2(const Byte *digest, Byte c, Byte *dest)
+{
+  Byte buf[64];
+  memset(buf, c, 64);
+  for (unsigned i = 0; i < NSha1::kDigestSize; i++)
+    buf[i] ^= digest[i];
+  NSha1::CContext sha;
+  sha.Init();
+  sha.Update(buf, 64);
+  sha.Final(dest);
+}
+ 
+static void DeriveKey(NSha1::CContext &sha, Byte *key)
+{
+  Byte digest[NSha1::kDigestSize];
+  sha.Final(digest);
+  Byte temp[NSha1::kDigestSize * 2];
+  DeriveKey2(digest, 0x36, temp);
+  DeriveKey2(digest, 0x5C, temp + NSha1::kDigestSize);
+  memcpy(key, temp, 32);
+}
+
+void CKeyInfo::SetPassword(const Byte *data, UInt32 size)
+{
+  NSha1::CContext sha;
+  sha.Init();
+  sha.Update(data, size);
+  DeriveKey(sha, MasterKey);
+}
+
+STDMETHODIMP CBaseCoder::CryptoSetPassword(const Byte *data, UInt32 size)
+{
+  _key.SetPassword(data, size);
+  return S_OK;
+}
+
+HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream, UInt32 /* crc */, UInt64 /* unpackSize */)
+{
+  Byte temp[4];
+  RINOK(ReadStream_FALSE(inStream, temp, 2));
+  _ivSize = GetUi16(temp);
+  if (_ivSize == 0)
+  {
+    return E_NOTIMPL;
+    /*
+    SetUi32(_iv, crc);
+    for (int i = 0; i < 8; i++)
+     _iv[4 + i] = (Byte)(unpackSize >> (8 * i));
+    SetUi32(_iv + 12, 0);
+    */
+  }
+  else if (_ivSize == 16)
+  {
+    RINOK(ReadStream_FALSE(inStream, _iv, _ivSize));
+  }
+  else
+    return E_NOTIMPL;
+  RINOK(ReadStream_FALSE(inStream, temp, 4));
+  _remSize = GetUi32(temp);
+  const UInt32 kAlign = 16;
+  if (_remSize < 16 || _remSize > (1 << 18))
+    return E_NOTIMPL;
+  if (_remSize + kAlign > _buf.GetCapacity())
+  {
+    _buf.Free();
+    _buf.SetCapacity(_remSize + kAlign);
+    _bufAligned = (Byte *)((ptrdiff_t)((Byte *)_buf + kAlign - 1) & ~(ptrdiff_t)(kAlign - 1));
+  }
+  return ReadStream_FALSE(inStream, _bufAligned, _remSize);
+}
+
+HRESULT CDecoder::CheckPassword(bool &passwOK)
+{
+  passwOK = false;
+  if (_remSize < 16)
+    return E_NOTIMPL;
+  Byte *p = _bufAligned;
+  UInt16 format = GetUi16(p);
+  if (format != 3)
+    return E_NOTIMPL;
+  UInt16 algId = GetUi16(p + 2);
+  if (algId < kAES128)
+    return E_NOTIMPL;
+  algId -= kAES128;
+  if (algId > 2)
+    return E_NOTIMPL;
+  UInt16 bitLen = GetUi16(p + 4);
+  UInt16 flags = GetUi16(p + 6);
+  if (algId * 64 + 128 != bitLen)
+    return E_NOTIMPL;
+  _key.KeySize = 16 + algId * 8;
+  if ((flags & 1) == 0)
+    return E_NOTIMPL;
+  if ((flags & 0x4000) != 0)
+  {
+    // Use 3DES
+    return E_NOTIMPL;
+  }
+
+  UInt32 rdSize = GetUi16(p + 8);
+  if ((rdSize & 0xF) != 0 || rdSize + 16 > _remSize)
+    return E_NOTIMPL;
+  memmove(p, p + 10, rdSize);
+  Byte *validData = p + rdSize + 16;
+  if (GetUi32(validData - 6) != 0) // reserved
+    return E_NOTIMPL;
+  UInt32 validSize = GetUi16(validData - 2);
+  if ((validSize & 0xF) != 0 || 16 + rdSize + validSize != _remSize)
+    return E_NOTIMPL;
+
+
+  {
+    RINOK(SetKey(_key.MasterKey, _key.KeySize));
+    RINOK(SetInitVector(_iv, 16));
+    Init();
+    Filter(p, rdSize);
+  }
+
+  Byte fileKey[32];
+  NSha1::CContext sha;
+  sha.Init();
+  sha.Update(_iv, 16);
+  sha.Update(p, rdSize - 16); // we don't use last 16 bytes (PAD bytes)
+  DeriveKey(sha, fileKey);
+  
+  RINOK(SetKey(fileKey, _key.KeySize));
+  RINOK(SetInitVector(_iv, 16));
+  Init();
+  Filter(validData, validSize);
+
+  if (validSize < 4)
+    return E_NOTIMPL;
+  validSize -= 4;
+  if (GetUi32(validData + validSize) != CrcCalc(validData, validSize))
+    return S_OK;
+  passwOK = true;
+  Init();
+  return S_OK;
+}
+
+}}

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

@@ -0,0 +1,47 @@
+// Crypto/ZipStrong.h
+
+#ifndef __CRYPTO_ZIP_STRONG_H
+#define __CRYPTO_ZIP_STRONG_H
+
+#include "Common/Buffer.h"
+
+#include "../IPassword.h"
+
+#include "MyAes.h"
+
+namespace NCrypto {
+namespace NZipStrong {
+
+struct CKeyInfo
+{
+  Byte MasterKey[32];
+  UInt32 KeySize;
+  void SetPassword(const Byte *data, UInt32 size);
+};
+
+class CBaseCoder:
+  public CAesCbcDecoder,
+  public ICryptoSetPassword
+{
+protected:
+  CKeyInfo _key;
+  CByteBuffer _buf;
+  Byte *_bufAligned;
+public:
+  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+};
+
+class CDecoder: public CBaseCoder
+{
+  UInt32 _ivSize;
+  Byte _iv[16];
+  UInt32 _remSize;
+public:
+  MY_UNKNOWN_IMP1(ICryptoSetPassword)
+  HRESULT ReadHeader(ISequentialInStream *inStream, UInt32 crc, UInt64 unpackSize);
+  HRESULT CheckPassword(bool &passwOK);
+};
+
+}}
+
+#endif