3.13

7zip/Crypto/Zip/StdAfx.h

@@ -0,0 +1,8 @@
+// stdafx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+#include <windows.h>
+
+#endif 

7zip/Crypto/Zip/ZipCipher.cpp

@@ -0,0 +1,118 @@
+// Crypto/ZipCipher.h
+
+#include "StdAfx.h"
+
+#include "ZipCipher.h"
+#include "Windows/Defs.h"
+
+namespace NCrypto {
+namespace NZip {
+
+const int kBufferSize = 1 << 17;
+
+CBuffer2::CBuffer2():
+  _buffer(0)
+{
+  _buffer = new BYTE[kBufferSize];
+}
+
+CBuffer2::~CBuffer2()
+{
+  delete []_buffer;
+}
+
+STDMETHODIMP CEncoder::CryptoSetPassword(const BYTE *data, UINT32 size)
+{
+  _cipher.SetPassword(data, size);
+  return S_OK;
+}
+
+STDMETHODIMP CEncoder::CryptoSetCRC(UINT32 crc)
+{
+  _crc = crc;
+  return S_OK;
+}
+
+STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream, const UINT64 *inSize, const UINT64 *outSize,
+      ICompressProgressInfo *progress)
+{
+  CRandom random;
+  random.Init(::GetTickCount());
+
+  UINT64 nowPos = 0;
+  BYTE header[kHeaderSize];
+  for (int i = 0; i < kHeaderSize - 2; i++)
+  {
+    header[i] = BYTE(random.Generate());
+  }
+  header[kHeaderSize - 1] = BYTE(_crc >> 24);
+  header[kHeaderSize - 2] = BYTE(_crc >> 16);
+
+  UINT32 processedSize;
+  _cipher.EncryptHeader(header);
+  RINOK(outStream->Write(header, kHeaderSize, &processedSize));
+  if (processedSize != kHeaderSize)
+    return E_FAIL;
+
+  while(true)
+  {
+    if (outSize != NULL && nowPos == *outSize)
+      return S_OK;
+    RINOK(inStream->Read(_buffer, kBufferSize, &processedSize));
+    if (processedSize == 0)
+      return S_OK;
+    for (UINT32 i = 0; i < processedSize; i++)
+      _buffer[i] = _cipher.EncryptByte(_buffer[i]);
+    UINT32 size = processedSize;
+    if (outSize != NULL && nowPos + size > *outSize)
+       size = UINT32(*outSize - nowPos);
+    RINOK(outStream->Write(_buffer, size, &processedSize));
+    if (size != processedSize)
+      return E_FAIL;
+    nowPos +=  processedSize;
+  }
+}
+
+STDMETHODIMP CDecoder::CryptoSetPassword(const BYTE *data, UINT32 size)
+{
+  _cipher.SetPassword(data, size);
+  return S_OK;
+}
+
+STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream, const UINT64 *inSize, const UINT64 *outSize,
+      ICompressProgressInfo *progress)
+{
+  UINT64 nowPos = 0;
+
+  if (inSize != NULL && *inSize == 0)
+    return S_OK;
+
+  BYTE header[kHeaderSize];
+  UINT32 processedSize;
+  RINOK(inStream->Read(header, kHeaderSize, &processedSize));
+  if (processedSize != kHeaderSize)
+    return E_FAIL;
+  _cipher.DecryptHeader(header);
+
+  while(true)
+  {
+    if (outSize != NULL && nowPos == *outSize)
+      return S_OK;
+    RINOK(inStream->Read(_buffer, kBufferSize, &processedSize));
+    if (processedSize == 0)
+      return S_OK;
+    for (UINT32 i = 0; i < processedSize; i++)
+      _buffer[i] = _cipher.DecryptByte(_buffer[i]);
+    UINT32 size = processedSize;
+    if (outSize != NULL && nowPos + size > *outSize)
+       size = UINT32(*outSize - nowPos);
+    RINOK(outStream->Write(_buffer, size, &processedSize));
+    if (size != processedSize)
+      return E_FAIL;
+    nowPos +=  processedSize;
+  }
+}
+
+}}

7zip/Crypto/Zip/ZipCipher.h

@@ -0,0 +1,72 @@
+// Crypto/ZipCipher.h
+
+#ifndef __CRYPTO_ZIPCIPHER_H
+#define __CRYPTO_ZIPCIPHER_H
+
+#include "Common/MyCom.h"
+#include "Common/Random.h"
+#include "Common/Types.h"
+
+#include "../../ICoder.h"
+#include "../../IPassword.h"
+
+#include "ZipCrypto.h"
+
+namespace NCrypto {
+namespace NZip {
+
+class CBuffer2
+{
+protected:
+  BYTE *_buffer;
+public:
+  CBuffer2();
+  ~CBuffer2();
+};
+
+class CEncoder : 
+  public ICompressCoder,
+  public ICryptoSetPassword,
+  public ICryptoSetCRC,
+  public CMyUnknownImp,
+  public CBuffer2
+{
+  CCipher _cipher;
+  UINT32 _crc;
+public:
+  MY_UNKNOWN_IMP2(
+      ICryptoSetPassword,
+      ICryptoSetCRC
+  )
+
+  STDMETHOD(Code)(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream, const UINT64 *inSize, const UINT64 *outSize,
+      ICompressProgressInfo *progress);
+
+  STDMETHOD(CryptoSetPassword)(const BYTE *data, UINT32 size);
+  STDMETHOD(CryptoSetCRC)(UINT32 crc);
+};
+
+
+class CDecoder: 
+  public ICompressCoder,
+  public ICryptoSetPassword,
+  public CMyUnknownImp,
+  public CBuffer2
+{
+  CCipher _cipher;
+public:
+
+  MY_UNKNOWN_IMP1(ICryptoSetPassword)
+
+  STDMETHOD(Code)(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream, UINT64 const *inSize, 
+      const UINT64 *outSize,
+      ICompressProgressInfo *progress);
+
+  STDMETHOD(CryptoSetPassword)(const BYTE *data, UINT32 size);
+};
+
+}}
+
+#endif

7zip/Crypto/Zip/ZipCrypto.cpp

@@ -0,0 +1,65 @@
+// Crypto/ZipCrypto.cpp
+
+#include "StdAfx.h"
+
+#include "ZipCipher.h"
+#include "Common/Crc.h"
+
+namespace NCrypto {
+namespace NZip {
+
+inline UINT32 CRC32(UINT32 c, BYTE  b)
+{
+  return CCRC::Table[(c ^ b) & 0xFF] ^ (c >> 8);
+}
+
+void CCipher::UpdateKeys(BYTE b)
+{
+  Keys[0] = CRC32(Keys[0], b);
+  Keys[1] += Keys[0] & 0xff;
+  Keys[1] = Keys[1] * 134775813L + 1;
+  Keys[2] = CRC32(Keys[2], Keys[1] >> 24);
+}
+
+void CCipher::SetPassword(const BYTE *password, UINT32 passwordLength)
+{
+  Keys[0] = 305419896L;
+  Keys[1] = 591751049L;
+  Keys[2] = 878082192L;
+  for (UINT32 i = 0; i < passwordLength; i++)
+    UpdateKeys(password[i]);
+}
+
+BYTE CCipher::DecryptByteSpec()
+{
+  UINT32 temp = Keys[2] | 2;
+  return (temp * (temp ^ 1)) >> 8;
+}
+
+BYTE CCipher::DecryptByte(BYTE encryptedByte)
+{
+  BYTE c = encryptedByte ^ DecryptByteSpec();
+  UpdateKeys(c);
+  return c;
+}
+
+BYTE CCipher::EncryptByte(BYTE b)
+{
+  BYTE c = b ^ DecryptByteSpec();
+  UpdateKeys(b);
+  return c;
+}
+
+void CCipher::DecryptHeader(BYTE *buffer)
+{
+  for (int i = 0; i < 12; i++)
+    buffer[i] = DecryptByte(buffer[i]);
+}
+
+void CCipher::EncryptHeader(BYTE *buffer)
+{
+  for (int i = 0; i < 12; i++)
+    buffer[i] = EncryptByte(buffer[i]);
+}
+
+}}

7zip/Crypto/Zip/ZipCrypto.h

@@ -0,0 +1,28 @@
+// Crypto/ZipCrypto.h
+
+#pragma once
+
+#ifndef __CRYPTO_ZIP_CRYPTO_H
+#define __CRYPTO_ZIP_CRYPTO_H
+
+namespace NCrypto {
+namespace NZip {
+
+const int kHeaderSize = 12;
+class CCipher
+{
+  UINT32 Keys[3];
+  void UpdateKeys(BYTE b);
+  BYTE DecryptByteSpec();
+public:
+  void SetPassword(const BYTE *password, UINT32 passwordLength);
+  BYTE DecryptByte(BYTE encryptedByte);
+  BYTE EncryptByte(BYTE b);
+  void DecryptHeader(BYTE *buffer);
+  void EncryptHeader(BYTE *buffer);
+
+};
+
+}}
+
+#endif