seven-zip 1.4.0

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

@@ -0,0 +1,229 @@
+// Crypto/Sha1.cpp
+// This file is based on public domain
+// Steve Reid and Wei Dai's code from Crypto++
+
+#include "StdAfx.h"
+
+#include "../../../C/RotateDefs.h"
+
+#include "Sha1.h"
+
+namespace NCrypto {
+namespace NSha1 {
+
+// define it for speed optimization
+// #define _SHA1_UNROLL
+
+static const unsigned kNumW =
+  #ifdef _SHA1_UNROLL
+  16;
+  #else
+  80;
+  #endif
+  
+
+#define w0(i) (W[(i)] = data[(i)])
+
+#ifdef _SHA1_UNROLL
+#define w1(i) (W[(i)&15] = rotlFixed(W[((i)-3)&15] ^ W[((i)-8)&15] ^ W[((i)-14)&15] ^ W[((i)-16)&15], 1))
+#else
+#define w1(i) (W[(i)] = rotlFixed(W[(i)-3] ^ W[(i)-8] ^ W[(i)-14] ^ W[(i)-16], 1))
+#endif
+
+#define f1(x,y,z) (z^(x&(y^z)))
+#define f2(x,y,z) (x^y^z)
+#define f3(x,y,z) ((x&y)|(z&(x|y)))
+#define f4(x,y,z) (x^y^z)
+
+#define RK1(a,b,c,d,e,i, f, w, k) e += f(b,c,d) + w(i) + k + rotlFixed(a,5); b = rotlFixed(b,30);
+
+#define R0(a,b,c,d,e,i) RK1(a,b,c,d,e,i, f1, w0, 0x5A827999)
+#define R1(a,b,c,d,e,i) RK1(a,b,c,d,e,i, f1, w1, 0x5A827999)
+#define R2(a,b,c,d,e,i) RK1(a,b,c,d,e,i, f2, w1, 0x6ED9EBA1)
+#define R3(a,b,c,d,e,i) RK1(a,b,c,d,e,i, f3, w1, 0x8F1BBCDC)
+#define R4(a,b,c,d,e,i) RK1(a,b,c,d,e,i, f4, w1, 0xCA62C1D6)
+
+#define RX_1_4(rx1, rx4, i) rx1(a,b,c,d,e,i); rx4(e,a,b,c,d,i+1); rx4(d,e,a,b,c,i+2); rx4(c,d,e,a,b,i+3); rx4(b,c,d,e,a,i+4);
+#define RX_5(rx, i) RX_1_4(rx, rx, i);
+
+void CContextBase::Init()
+{
+  _state[0] = 0x67452301;
+  _state[1] = 0xEFCDAB89;
+  _state[2] = 0x98BADCFE;
+  _state[3] = 0x10325476;
+  _state[4] = 0xC3D2E1F0;
+  _count = 0;
+}
+
+void CContextBase::GetBlockDigest(UInt32 *data, UInt32 *destDigest, bool returnRes)
+{
+  UInt32 a, b, c, d, e;
+  UInt32 W[kNumW];
+
+  a = _state[0];
+  b = _state[1];
+  c = _state[2];
+  d = _state[3];
+  e = _state[4];
+  #ifdef _SHA1_UNROLL
+  RX_5(R0, 0); RX_5(R0, 5); RX_5(R0, 10);
+  #else
+  int i;
+  for (i = 0; i < 15; i += 5) { RX_5(R0, i); }
+  #endif
+
+  RX_1_4(R0, R1, 15);
+
+
+  #ifdef _SHA1_UNROLL
+  RX_5(R2, 20); RX_5(R2, 25); RX_5(R2, 30); RX_5(R2, 35);
+  RX_5(R3, 40); RX_5(R3, 45); RX_5(R3, 50); RX_5(R3, 55);
+  RX_5(R4, 60); RX_5(R4, 65); RX_5(R4, 70); RX_5(R4, 75);
+  #else
+  i = 20;
+  for (; i < 40; i += 5) { RX_5(R2, i); }
+  for (; i < 60; i += 5) { RX_5(R3, i); }
+  for (; i < 80; i += 5) { RX_5(R4, i); }
+  #endif
+
+  destDigest[0] = _state[0] + a;
+  destDigest[1] = _state[1] + b;
+  destDigest[2] = _state[2] + c;
+  destDigest[3] = _state[3] + d;
+  destDigest[4] = _state[4] + e;
+
+  if (returnRes)
+    for (int i = 0 ; i < 16; i++)
+      data[i] = W[kNumW - 16 + i];
+  
+  // Wipe variables
+  // a = b = c = d = e = 0;
+}
+
+void CContextBase::PrepareBlock(UInt32 *block, unsigned size) const
+{
+  unsigned curBufferPos = size & 0xF;
+  block[curBufferPos++] = 0x80000000;
+  while (curBufferPos != (16 - 2))
+    block[curBufferPos++] = 0;
+  const UInt64 lenInBits = (_count << 9) + ((UInt64)size << 5);
+  block[curBufferPos++] = (UInt32)(lenInBits >> 32);
+  block[curBufferPos++] = (UInt32)(lenInBits);
+}
+
+void CContext::Update(const Byte *data, size_t size)
+{
+  unsigned curBufferPos = _count2;
+  while (size--)
+  {
+    int pos = (int)(curBufferPos & 3);
+    if (pos == 0)
+      _buffer[curBufferPos >> 2] = 0;
+    _buffer[curBufferPos >> 2] |= ((UInt32)*data++) << (8 * (3 - pos));
+    if (++curBufferPos == kBlockSize)
+    {
+      curBufferPos = 0;
+      CContextBase::UpdateBlock(_buffer, false);
+    }
+  }
+  _count2 = curBufferPos;
+}
+
+void CContext::UpdateRar(Byte *data, size_t size, bool rar350Mode)
+{
+  bool returnRes = false;
+  unsigned curBufferPos = _count2;
+  while (size--)
+  {
+    int pos = (int)(curBufferPos & 3);
+    if (pos == 0)
+      _buffer[curBufferPos >> 2] = 0;
+    _buffer[curBufferPos >> 2] |= ((UInt32)*data++) << (8 * (3 - pos));
+    if (++curBufferPos == kBlockSize)
+    {
+      curBufferPos = 0;
+      CContextBase::UpdateBlock(_buffer, returnRes);
+      if (returnRes)
+        for (int i = 0; i < kBlockSizeInWords; i++)
+        {
+          UInt32 d = _buffer[i];
+          data[i * 4 + 0 - kBlockSize] = (Byte)(d);
+          data[i * 4 + 1 - kBlockSize] = (Byte)(d >>  8);
+          data[i * 4 + 2 - kBlockSize] = (Byte)(d >> 16);
+          data[i * 4 + 3 - kBlockSize] = (Byte)(d >> 24);
+        }
+      returnRes = rar350Mode;
+    }
+  }
+  _count2 = curBufferPos;
+}
+
+void CContext::Final(Byte *digest)
+{
+  const UInt64 lenInBits = (_count << 9) + ((UInt64)_count2 << 3);
+  unsigned curBufferPos = _count2;
+  int pos = (int)(curBufferPos & 3);
+  curBufferPos >>= 2;
+  if (pos == 0)
+    _buffer[curBufferPos] = 0;
+  _buffer[curBufferPos++] |= ((UInt32)0x80) << (8 * (3 - pos));
+
+  while (curBufferPos != (16 - 2))
+  {
+    curBufferPos &= 0xF;
+    if (curBufferPos == 0)
+      UpdateBlock();
+    _buffer[curBufferPos++] = 0;
+  }
+  _buffer[curBufferPos++] = (UInt32)(lenInBits >> 32);
+  _buffer[curBufferPos++] = (UInt32)(lenInBits);
+  UpdateBlock();
+
+  int i;
+  for (i = 0; i < kDigestSizeInWords; i++)
+  {
+    UInt32 state = _state[i] & 0xFFFFFFFF;
+    *digest++ = (Byte)(state >> 24);
+    *digest++ = (Byte)(state >> 16);
+    *digest++ = (Byte)(state >> 8);
+    *digest++ = (Byte)(state);
+  }
+  Init();
+}
+
+///////////////////////////
+// Words version
+
+void CContext32::Update(const UInt32 *data, size_t size)
+{
+  while (size--)
+  {
+    _buffer[_count2++] = *data++;
+    if (_count2 == kBlockSizeInWords)
+    {
+      _count2 = 0;
+      UpdateBlock();
+    }
+  }
+}
+
+void CContext32::Final(UInt32 *digest)
+{
+  const UInt64 lenInBits = (_count << 9) + ((UInt64)_count2 << 5);
+  unsigned curBufferPos = _count2;
+  _buffer[curBufferPos++] = 0x80000000;
+  while (curBufferPos != (16 - 2))
+  {
+    curBufferPos &= 0xF;
+    if (curBufferPos == 0)
+      UpdateBlock();
+    _buffer[curBufferPos++] = 0;
+  }
+  _buffer[curBufferPos++] = (UInt32)(lenInBits >> 32);
+  _buffer[curBufferPos++] = (UInt32)(lenInBits);
+  GetBlockDigest(_buffer, digest);
+  Init();
+}
+
+}}

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

@@ -0,0 +1,68 @@
+// Crypto/Sha1.h
+// This file is based on public domain
+// Steve Reid and Wei Dai's code from Crypto++
+
+#ifndef __CRYPTO_SHA1_H
+#define __CRYPTO_SHA1_H
+
+#include <stddef.h>
+#include "../../Common/Types.h"
+
+// Sha1 implementation in RAR before version 3.60 has bug:
+// it changes data bytes in some cases.
+// So this class supports both versions: normal_SHA and rar3Mode
+
+namespace NCrypto {
+namespace NSha1 {
+
+const unsigned kBlockSize = 64;
+const unsigned kDigestSize = 20;
+
+const unsigned kBlockSizeInWords = (kBlockSize >> 2);
+const unsigned kDigestSizeInWords = (kDigestSize >> 2);
+
+class CContextBase
+{
+protected:
+  UInt32 _state[5];
+  UInt64 _count;
+  void UpdateBlock(UInt32 *data, bool returnRes = false)
+  {
+    GetBlockDigest(data, _state, returnRes);
+    _count++;
+  }
+public:
+  void Init();
+  void GetBlockDigest(UInt32 *blockData, UInt32 *destDigest, bool returnRes = false);
+  // PrepareBlock can be used only when size <= 13. size in Words
+  void PrepareBlock(UInt32 *block, unsigned int size) const;
+};
+
+class CContextBase2: public CContextBase
+{
+protected:
+  unsigned _count2;
+  UInt32 _buffer[kBlockSizeInWords];
+  void UpdateBlock() { CContextBase::UpdateBlock(_buffer); }
+public:
+  void Init() { CContextBase::Init(); _count2 = 0; }
+};
+
+class CContext: public CContextBase2
+{
+public:
+  void Update(const Byte *data, size_t size);
+  void UpdateRar(Byte *data, size_t size, bool rar350Mode);
+  void Final(Byte *digest);
+};
+
+class CContext32: public CContextBase2
+{
+public:
+  void Update(const UInt32 *data, size_t size);
+  void Final(UInt32 *digest);
+};
+
+}}
+
+#endif

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

@@ -0,0 +1,221 @@
+// Crypto/WzAes.cpp
+/*
+This code implements Brian Gladman's scheme
+specified in 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 "../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 _NO_WZAES_OPTIMIZATIONS
+
+namespace NCrypto {
+namespace NWzAes {
+
+const unsigned kAesKeySizeMax = 32;
+
+static const UInt32 kNumKeyGenIterations = 1000;
+
+STDMETHODIMP CBaseCoder::CryptoSetPassword(const Byte *data, UInt32 size)
+{
+  if(size > kPasswordSizeMax)
+    return E_INVALIDARG;
+  _key.Password.SetCapacity(size);
+  memcpy(_key.Password, data, size);
+  return S_OK;
+}
+
+#ifndef _NO_WZAES_OPTIMIZATIONS
+
+static void BytesToBeUInt32s(const Byte *src, UInt32 *dest, unsigned destSize)
+{
+  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]));
+}
+
+#endif
+
+STDMETHODIMP CBaseCoder::Init()
+{
+  UInt32 keySize = _key.GetKeySize();
+  UInt32 keysTotalSize = 2 * keySize + kPwdVerifCodeSize;
+  Byte buf[2 * kAesKeySizeMax + kPwdVerifCodeSize];
+  
+  // 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);
+
+    #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);
+    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)));
+    
+    #endif
+  }
+
+  _hmac.SetKey(buf + keySize, keySize);
+  memcpy(_key.PwdVerifComputed, buf + 2 * keySize, kPwdVerifCodeSize);
+
+  AesCtr2_Init(&_aes);
+  Aes_SetKey_Enc(_aes.aes + _aes.offset + 8, buf, keySize);
+  return S_OK;
+}
+
+HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream)
+{
+  UInt32 saltSize = _key.GetSaltSize();
+  g_RandomGenerator.Generate(_key.Salt, saltSize);
+  Init();
+  RINOK(WriteStream(outStream, _key.Salt, saltSize));
+  return WriteStream(outStream, _key.PwdVerifComputed, kPwdVerifCodeSize);
+}
+
+HRESULT CEncoder::WriteFooter(ISequentialOutStream *outStream)
+{
+  Byte mac[kMacSize];
+  _hmac.Final(mac, kMacSize);
+  return WriteStream(outStream, mac, kMacSize);
+}
+
+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
+{
+  if (size != 1)
+    return E_INVALIDARG;
+  _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];
+  RINOK(ReadStream_FAIL(inStream, temp, extraSize));
+  UInt32 i;
+  for (i = 0; i < saltSize; i++)
+    _key.Salt[i] = temp[i];
+  for (i = 0; i < kPwdVerifCodeSize; i++)
+    _pwdVerifFromArchive[i] = temp[saltSize + i];
+  return S_OK;
+}
+
+static bool CompareArrays(const Byte *p1, const Byte *p2, UInt32 size)
+{
+  for (UInt32 i = 0; i < size; i++)
+    if (p1[i] != p2[i])
+      return false;
+  return true;
+}
+
+bool CDecoder::CheckPasswordVerifyCode()
+{
+  return CompareArrays(_key.PwdVerifComputed, _pwdVerifFromArchive, kPwdVerifCodeSize);
+}
+
+HRESULT CDecoder::CheckMac(ISequentialInStream *inStream, bool &isOK)
+{
+  isOK = false;
+  Byte mac1[kMacSize];
+  RINOK(ReadStream_FAIL(inStream, mac1, kMacSize));
+  Byte mac2[kMacSize];
+  _hmac.Final(mac2, kMacSize);
+  isOK = CompareArrays(mac1, mac2, kMacSize);
+  return S_OK;
+}
+
+CAesCtr2::CAesCtr2()
+{
+  offset = ((0 - (unsigned)(ptrdiff_t)aes) & 0xF) / sizeof(UInt32);
+}
+
+void AesCtr2_Init(CAesCtr2 *p)
+{
+  UInt32 *ctr = p->aes + p->offset + 4;
+  unsigned i;
+  for (i = 0; i < 4; i++)
+    ctr[i] = 0;
+  p->pos = AES_BLOCK_SIZE;
+}
+
+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;
+    do
+      *data++ ^= buf[pos++];
+    while (--size != 0 && pos != AES_BLOCK_SIZE);
+  }
+  if (size >= 16)
+  {
+    SizeT size2 = size >> 4;
+    g_AesCtr_Code(buf32 + 4, data, size2);
+    size2 <<= 4;
+    data += size2;
+    size -= size2;
+    pos = AES_BLOCK_SIZE;
+  }
+  if (size != 0)
+  {
+    unsigned j;
+    const Byte *buf;
+    for (j = 0; j < 4; j++)
+      buf32[j] = 0;
+    g_AesCtr_Code(buf32 + 4, (Byte *)buf32, 1);
+    buf = (const Byte *)buf32;
+    pos = 0;
+    do
+      *data++ ^= buf[pos++];
+    while (--size != 0 && pos != AES_BLOCK_SIZE);
+  }
+  p->pos = pos;
+}
+
+STDMETHODIMP_(UInt32) CEncoder::Filter(Byte *data, UInt32 size)
+{
+  AesCtr2_Code(&_aes, data, size);
+  _hmac.Update(data, size);
+  return size;
+}
+
+STDMETHODIMP_(UInt32) CDecoder::Filter(Byte *data, UInt32 size)
+{
+  _hmac.Update(data, size);
+  AesCtr2_Code(&_aes, data, size);
+  return size;
+}
+
+}}

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