seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -7,8 +7,7 @@
 
 #include "../Common/StreamUtils.h"
 
-#include "MyAes.h"
-#include "Sha1.h"
+#include "Sha1Cls.h"
 #include "ZipStrong.h"
 
 namespace NCrypto {
@@ -57,20 +56,22 @@ STDMETHODIMP CBaseCoder::CryptoSetPassword(const Byte *data, UInt32 size)
   return S_OK;
 }
 
-HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream, UInt32 /* crc */, UInt64 /* unpackSize */)
+STDMETHODIMP CBaseCoder::Init()
+{
+  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);
-    */
+    memset(_iv, 0, 16);
+    SetUi32(_iv + 0, crc);
+    SetUi64(_iv + 4, unpackSize);
+    _ivSize = 12;
   }
   else if (_ivSize == 16)
   {
@@ -83,16 +84,15 @@ HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream, UInt32 /* crc */, UI
   const UInt32 kAlign = 16;
   if (_remSize < 16 || _remSize > (1 << 18))
     return E_NOTIMPL;
-  if (_remSize + kAlign > _buf.GetCapacity())
+  if (_remSize + kAlign > _buf.Size())
   {
-    _buf.Free();
-    _buf.SetCapacity(_remSize + kAlign);
+    _buf.Alloc(_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)
+HRESULT CDecoder::Init_and_CheckPassword(bool &passwOK)
 {
   passwOK = false;
   if (_remSize < 16)
@@ -112,52 +112,114 @@ HRESULT CDecoder::CheckPassword(bool &passwOK)
   if (algId * 64 + 128 != bitLen)
     return E_NOTIMPL;
   _key.KeySize = 16 + algId * 8;
-  if ((flags & 1) == 0)
-    return E_NOTIMPL;
+  bool cert = ((flags & 2) != 0);
+
   if ((flags & 0x4000) != 0)
   {
     // Use 3DES
     return E_NOTIMPL;
   }
 
+  if (cert)
+  {
+    return E_NOTIMPL;
+  }
+  else
+  {
+    if ((flags & 1) == 0)
+      return E_NOTIMPL;
+  }
+
   UInt32 rdSize = GetUi16(p + 8);
-  if ((rdSize & 0xF) != 0 || rdSize + 16 > _remSize)
+
+  if (rdSize + 16 > _remSize)
     return E_NOTIMPL;
+
+  /*
+  if (cert)
+  {
+    // how to filter rd, if ((rdSize & 0xF) != 0) ?
+    if ((rdSize & 0x7) != 0)
+      return E_NOTIMPL;
+  }
+  else
+  */
+  {
+    if ((rdSize & 0xF) != 0)
+      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;
+  const Byte *p2 = p + rdSize + 10;
+  UInt32 reserved = GetUi32(p2);
+  p2 += 4;
+  
+  /*
+  if (cert)
+  {
+    UInt32 numRecipients = reserved;
+
+    if (numRecipients == 0)
+      return E_NOTIMPL;
+
+    {
+      UInt32 hashAlg = GetUi16(p2);
+      hashAlg = hashAlg;
+      UInt32 hashSize = GetUi16(p2 + 2);
+      hashSize = hashSize;
+      p2 += 4;
+
+      reserved = reserved;
+      // return E_NOTIMPL;
+
+      for (unsigned r = 0; r < numRecipients; r++)
+      {
+        UInt32 specSize = GetUi16(p2);
+        p2 += 2;
+        p2 += specSize;
+      }
+    }
+  }
+  else
+  */
+  {
+    if (reserved != 0)
+      return E_NOTIMPL;
+  }
 
+  UInt32 validSize = GetUi16(p2);
+  p2 += 2;
+  const size_t validOffset = p2 - p;
+  if ((validSize & 0xF) != 0 || validOffset + validSize != _remSize)
+    return E_NOTIMPL;
 
   {
     RINOK(SetKey(_key.MasterKey, _key.KeySize));
     RINOK(SetInitVector(_iv, 16));
-    Init();
+    RINOK(Init());
     Filter(p, rdSize);
   }
 
   Byte fileKey[32];
   NSha1::CContext sha;
   sha.Init();
-  sha.Update(_iv, 16);
+  sha.Update(_iv, _ivSize);
   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);
+
+  memmove(p, p + validOffset, validSize);
+  Filter(p, validSize);
 
   if (validSize < 4)
     return E_NOTIMPL;
   validSize -= 4;
-  if (GetUi32(validData + validSize) != CrcCalc(validData, validSize))
+  if (GetUi32(p + validSize) != CrcCalc(p, validSize))
     return S_OK;
   passwOK = true;
-  Init();
   return S_OK;
 }
 

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

@@ -3,7 +3,7 @@
 #ifndef __CRYPTO_ZIP_STRONG_H
 #define __CRYPTO_ZIP_STRONG_H
 
-#include "Common/Buffer.h"
+#include "../../Common/MyBuffer.h"
 
 #include "../IPassword.h"
 
@@ -12,10 +12,20 @@
 namespace NCrypto {
 namespace NZipStrong {
 
+/* ICompressFilter::Init() does nothing for this filter.
+  Call to init:
+    Decoder:
+      [CryptoSetPassword();]
+      ReadHeader();
+      [CryptoSetPassword();] Init_and_CheckPassword();
+      [CryptoSetPassword();] Init_and_CheckPassword();
+*/
+
 struct CKeyInfo
 {
   Byte MasterKey[32];
   UInt32 KeySize;
+  
   void SetPassword(const Byte *data, UInt32 size);
 };
 
@@ -28,6 +38,7 @@ protected:
   CByteBuffer _buf;
   Byte *_bufAligned;
 public:
+  STDMETHOD(Init)();
   STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
 };
 
@@ -39,7 +50,7 @@ class CDecoder: public CBaseCoder
 public:
   MY_UNKNOWN_IMP1(ICryptoSetPassword)
   HRESULT ReadHeader(ISequentialInStream *inStream, UInt32 crc, UInt64 unpackSize);
-  HRESULT CheckPassword(bool &passwOK);
+  HRESULT Init_and_CheckPassword(bool &passwOK);
 };
 
 }}

data/ext/p7zip/CPP/7zip/Guid.txt

@@ -3,17 +3,25 @@
 00 IProgress.h
 
   05  IProgress
+  // 050002  IProgress2
 
 01 IFolderArchive.h
 
-  05  IArchiveFolder
+  // 05  IArchiveFolder   // old 
   // 06  IInFolderArchive // old
   07  IFileExtractCallback.h::IFolderArchiveExtractCallback
-  0A  IOutFolderArchive
+  08  IFileExtractCallback.h::IFolderArchiveExtractCallback2
+  // 0A  IOutFolderArchive
   0B  IFolderArchiveUpdateCallback
   0C  Agent.h::IArchiveFolderInternal
-  0D
+  0D  IArchiveFolder
   0E  IInFolderArchive
+  0F  IOutFolderArchive
+  10  IFolderArchiveUpdateCallback2
+  11  IFolderScanProgress
+  
+  20  IFileExtractCallback.h::IGetProp
+  30  IFileExtractCallback.h::IFolderExtractToStreamCallback
 
 03 IStream.h
 
@@ -22,7 +30,9 @@
   03  IInStream
   04  IOutStream
   06  IStreamGetSize
-  07  IOutStreamFlush
+  07  IOutStreamFinish
+  08  IStreamGetProps
+  09  IStreamGetProps2
 
 
 04 ICoder.h
@@ -36,12 +46,20 @@
   23  ICompressWriteCoderProperties
   24  ICompressGetInStreamProcessedSize
   25  ICompressSetCoderMt
+  26  ICompressSetFinishMode
+
   30  ICompressGetSubStreamSize
   31  ICompressSetInStream
   32  ICompressSetOutStream
-  33  ICompressSetInStreamSize
+//  33  ICompressSetInStreamSize
   34  ICompressSetOutStreamSize
   35  ICompressSetBufSize
+  36  ICompressInitEncoder
+  37  ICompressSetInStream2
+//  38  ICompressSetOutStream2
+//  39  SetInStreamSize2
+//  3A  SetOutStreamSize2
+
   40  ICompressFilter
   60  ICompressCodecsInfo
   61  ISetCompressCodecsInfo
@@ -50,6 +68,8 @@
   8C  ICryptoResetInitVector
   90  ICryptoSetPassword
   A0  ICryptoSetCRC
+  C0  IHasher
+  C1  IHashers
 
 
 05 IPassword.h
@@ -61,17 +81,26 @@
 06 IArchive.h
 
   03  ISetProperties
+  04  IArchiveKeepModeForNextOpen
+  05  IArchiveAllowTail
 
   10  IArchiveOpenCallback
+  
   20  IArchiveExtractCallback
+  21  IArchiveExtractCallbackMessage
+  
   30  IArchiveOpenVolumeCallback
   40  IInArchiveGetStream
   50  IArchiveOpenSetSubArchiveName
   60  IInArchive
   61  IArchiveOpenSeq
+  70  IArchiveGetRawProps
+  71  IArchiveGetRootProps
 
   80  IArchiveUpdateCallback
   82  IArchiveUpdateCallback2
+  83  IArchiveUpdateCallbackFile
+
   A0  IOutArchive
 
 
@@ -84,7 +113,7 @@
   03 IFolderGetPath
   04 IFolderWasChanged
   05 // IFolderReload
-  06 IFolderOperations
+  06 // IFolderOperations old
   07 IFolderGetSystemIconIndex
   08 IFolderGetItemFullSize
   09 IFolderClone
@@ -96,6 +125,12 @@
   0F 
   10 IFolderArcProps
   11 IGetFolderArcProps
+  12 // IFolderOperations
+  13 IFolderOperations
+  14 IFolderCalcItemFullSize
+  15 IFolderCompare
+  16 IFolderGetItemName
+  17 IFolderAltStreams
 
 
 09 IFolder.h :: FOLDER_MANAGER_INTERFACE
@@ -128,6 +163,17 @@ Handler GUIDs:
   0C xz
   0D ppmd
 
+  C7 Ext
+  C8 VMDK
+  C9 VDI
+  CA Qcow
+  CB GPT
+  CC Rar5
+  CD IHex
+  CE Hxs
+  CF TE
+  D0 UEFIc
+  D1 UEFIs
   D2 SquashFS
   D3 CramFS
   D4 APM
@@ -150,7 +196,7 @@ Handler GUIDs:
   E5 Compound
   E6 Wim
   E7 Iso
-  E8 Bkf
+  E8 
   E9 Chm
   EA Split
   EB Rpm
@@ -159,12 +205,12 @@ Handler GUIDs:
   EE Tar
   EF GZip
 
-{23170F69-40C1-278A-1000-000100030000} CAgentArchiveHandle
 {23170F69-40C1-278A-1000-000100020000} ContextMenu.h::CZipContextMenu
 
-{23170F69-40C1-278B- old codecs clsids
-
-{23170F69-40C1-278D-1000-000100020000} OptionsDialog.h::CLSID_CSevenZipOptions
+// {23170F69-40C1-278A-1000-000100030000} // CAgentArchiveHandler
+// {23170F69-40C1-278B- old codecs clsids
+// {23170F69-40C1-278D-1000-000100020000} OptionsDialog.h::CLSID_CSevenZipOptions
 
 {23170F69-40C1-2790-id} Codec Decoders
 {23170F69-40C1-2791-id} Codec Encoders
+{23170F69-40C1-2792-id} Hashers

data/ext/p7zip/CPP/7zip/ICoder.h

@@ -10,6 +10,15 @@
 CODER_INTERFACE(ICompressProgressInfo, 0x04)
 {
   STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize) PURE;
+  
+  /* (inSize) can be NULL, if unknown
+     (outSize) can be NULL, if unknown
+
+  returns:
+    S_OK
+    E_ABORT  : Break by user
+    another error codes
+  */
 };
 
 CODER_INTERFACE(ICompressCoder, 0x05)
@@ -21,11 +30,75 @@ CODER_INTERFACE(ICompressCoder, 0x05)
 
 CODER_INTERFACE(ICompressCoder2, 0x18)
 {
-  STDMETHOD(Code)(ISequentialInStream **inStreams, const UInt64 **inSizes, UInt32 numInStreams,
-      ISequentialOutStream **outStreams, const UInt64 **outSizes, UInt32 numOutStreams,
+  STDMETHOD(Code)(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
+      ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
       ICompressProgressInfo *progress) PURE;
 };
 
+/*
+  ICompressCoder::Code
+  ICompressCoder2::Code
+  
+  returns:
+    S_OK     : OK
+    S_FALSE  : data error (for decoders)
+    E_OUTOFMEMORY : memory allocation error
+    another error code : some error. For example, it can be error code received from inStream or outStream function.
+  
+  Parameters:
+    (inStream != NULL)
+    (outStream != NULL)
+
+    if (inSize != NULL)
+    {
+      Encoders in 7-Zip ignore (inSize).
+      Decoder can use (*inSize) to check that stream was decoded correctly.
+      Some decoder in 7-Zip check it, if (full_decoding mode was set via ICompressSetFinishMode)
+    }
+
+    If it's required to limit the reading from input stream (inStream), it can
+      be done with ISequentialInStream implementation.
+
+    if (outSize != NULL)
+    {
+      Encoders in 7-Zip ignore (outSize).
+      Decoder unpacks no more than (*outSize) bytes.
+    }
+    
+    (progress == NULL) is allowed.
+
+
+  Decoding with Code() function
+  -----------------------------
+   
+  You can request some interfaces before decoding
+   - ICompressSetDecoderProperties2
+   - ICompressSetFinishMode
+
+  If you need to decode full stream:
+  {
+    1) try to set full_decoding mode with ICompressSetFinishMode::SetFinishMode(1);
+    2) call the Code() function with specified (inSize) and (outSize), if these sizes are known.
+  }
+
+  If you need to decode only part of stream:
+  {
+    1) try to set partial_decoding mode with ICompressSetFinishMode::SetFinishMode(0);
+    2) Call the Code() function with specified (inSize = NULL) and specified (outSize).
+  }
+
+  Encoding with Code() function
+  -----------------------------
+  
+  You can request some interfaces :
+  - ICompressSetCoderProperties   - use it before encoding to set properties
+  - ICompressWriteCoderProperties - use it before or after encoding to request encoded properties.
+
+  ICompressCoder2 is used when (numInStreams != 1 || numOutStreams != 1)
+     The rules are similar to ICompressCoder rules
+*/
+
+
 namespace NCoderPropID
 {
   enum EEnum
@@ -44,7 +117,9 @@ namespace NCoderPropID
     kNumPasses,
     kAlgorithm,
     kNumThreads,
-    kEndMarker
+    kEndMarker,
+    kLevel,
+    kReduceSize // estimated size of data that will be compressed. Encoder can use this value to reduce dictionary size.
   };
 }
 
@@ -62,6 +137,12 @@ CODER_INTERFACE(ICompressSetCoderProperties, 0x21)
 
 CODER_INTERFACE(ICompressSetDecoderProperties2, 0x22)
 {
+  /* returns:
+    S_OK
+    E_NOTIMP      : unsupported properties
+    E_INVALIDARG  : incorrect (or unsupported) properties
+    E_OUTOFMEMORY : memory allocation error
+  */
   STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size) PURE;
 };
 
@@ -80,9 +161,34 @@ CODER_INTERFACE(ICompressSetCoderMt, 0x25)
   STDMETHOD(SetNumberOfThreads)(UInt32 numThreads) PURE;
 };
 
+CODER_INTERFACE(ICompressSetFinishMode, 0x26)
+{
+  STDMETHOD(SetFinishMode)(UInt32 finishMode) PURE;
+
+  /* finishMode:
+    0 : partial decoding is allowed. It's default mode for ICompressCoder::Code(), if (outSize) is defined.
+    1 : full decoding. The stream must be finished at the end of decoding. */
+};
+
+
 CODER_INTERFACE(ICompressGetSubStreamSize, 0x30)
 {
   STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value) PURE;
+
+  /* returns:
+    S_OK     : (*value) contains the size or estimated size (can be incorrect size)
+    S_FALSE  : size is undefined
+    E_NOTIMP : the feature is not implemented
+
+  Let's (read_size) is size of data that was already read by ISequentialInStream::Read().
+  The caller should call GetSubStreamSize() after each Read() and check sizes:
+    if (start_of_subStream + *value < read_size)
+    {
+      // (*value) is correct, and it's allowed to call GetSubStreamSize() for next subStream:
+      start_of_subStream += *value;
+      subStream++;
+    }
+  */
 };
 
 CODER_INTERFACE(ICompressSetInStream, 0x31)
@@ -97,14 +203,21 @@ CODER_INTERFACE(ICompressSetOutStream, 0x32)
   STDMETHOD(ReleaseOutStream)() PURE;
 };
 
+/*
 CODER_INTERFACE(ICompressSetInStreamSize, 0x33)
 {
   STDMETHOD(SetInStreamSize)(const UInt64 *inSize) PURE;
 };
+*/
 
 CODER_INTERFACE(ICompressSetOutStreamSize, 0x34)
 {
   STDMETHOD(SetOutStreamSize)(const UInt64 *outSize) PURE;
+
+  /* That function initializes decoder structures.
+     Call this function only for stream version of decoder.
+       if (outSize == NULL), then output size is unknown
+       if (outSize != NULL), then the decoder must stop decoding after (*outSize) bytes. */
 };
 
 CODER_INTERFACE(ICompressSetBufSize, 0x35)
@@ -113,25 +226,62 @@ CODER_INTERFACE(ICompressSetBufSize, 0x35)
   STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size) PURE;
 };
 
+CODER_INTERFACE(ICompressInitEncoder, 0x36)
+{
+  STDMETHOD(InitEncoder)() PURE;
+
+  /* That function initializes encoder structures.
+     Call this function only for stream version of encoder. */
+};
+
+CODER_INTERFACE(ICompressSetInStream2, 0x37)
+{
+  STDMETHOD(SetInStream2)(UInt32 streamIndex, ISequentialInStream *inStream) PURE;
+  STDMETHOD(ReleaseInStream2)(UInt32 streamIndex) PURE;
+};
+
+/*
+CODER_INTERFACE(ICompressSetOutStream2, 0x38)
+{
+  STDMETHOD(SetOutStream2)(UInt32 streamIndex, ISequentialOutStream *outStream) PURE;
+  STDMETHOD(ReleaseOutStream2)(UInt32 streamIndex) PURE;
+};
+
+CODER_INTERFACE(ICompressSetInStreamSize2, 0x39)
+{
+  STDMETHOD(SetInStreamSize2)(UInt32 streamIndex, const UInt64 *inSize) PURE;
+};
+*/
+
+
+/*
+  ICompressFilter
+  Filter() converts as most as possible bytes
+     returns: (outSize):
+       if (outSize <= size) : Filter have converted outSize bytes
+       if (outSize >  size) : Filter have not converted anything.
+           and it needs at least outSize bytes to convert one block
+           (it's for crypto block algorithms).
+*/
+
+#define INTERFACE_ICompressFilter(x) \
+  STDMETHOD(Init)() x; \
+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) x; \
+
 CODER_INTERFACE(ICompressFilter, 0x40)
 {
-  STDMETHOD(Init)() PURE;
-  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) PURE;
-  // Filter converts as most as possible bytes
-  // Filter return outSize (UInt32)
-  // if (outSize <= size): Filter have converted outSize bytes
-  // if (outSize > size): Filter have not converted anything.
-  //      and it needs at least outSize bytes to convert one block
-  //      (it's for crypto block algorithms).
+  INTERFACE_ICompressFilter(PURE);
 };
 
+
 CODER_INTERFACE(ICompressCodecsInfo, 0x60)
 {
-  STDMETHOD(GetNumberOfMethods)(UInt32 *numMethods) PURE;
+  STDMETHOD(GetNumMethods)(UInt32 *numMethods) PURE;
   STDMETHOD(GetProperty)(UInt32 index, PROPID propID, PROPVARIANT *value) PURE;
   STDMETHOD(CreateDecoder)(UInt32 index, const GUID *iid, void **coder) PURE;
   STDMETHOD(CreateEncoder)(UInt32 index, const GUID *iid, void **coder) PURE;
 };
+
 CODER_INTERFACE(ISetCompressCodecsInfo, 0x61)
 {
   STDMETHOD(SetCompressCodecsInfo)(ICompressCodecsInfo *compressCodecsInfo) PURE;
@@ -153,6 +303,10 @@ CODER_INTERFACE(ICryptoResetSalt, 0x88)
 CODER_INTERFACE(ICryptoResetInitVector, 0x8C)
 {
   STDMETHOD(ResetInitVector)() PURE;
+
+  /* Call ResetInitVector() only for encoding.
+     Call ResetInitVector() before encoding and before WriteCoderProperties().
+     Crypto encoder can create random IV in that function. */
 };
 
 CODER_INTERFACE(ICryptoSetPassword, 0x90)
@@ -165,8 +319,7 @@ CODER_INTERFACE(ICryptoSetCRC, 0xA0)
   STDMETHOD(CryptoSetCRC)(UInt32 crc) PURE;
 };
 
-//////////////////////
-// It's for DLL file
+
 namespace NMethodPropID
 {
   enum EEnum
@@ -175,12 +328,44 @@ namespace NMethodPropID
     kName,
     kDecoder,
     kEncoder,
-    kInStreams,
-    kOutStreams,
+    kPackStreams,
+    kUnpackStreams,
     kDescription,
     kDecoderIsAssigned,
-    kEncoderIsAssigned
+    kEncoderIsAssigned,
+    kDigestSize
   };
 }
 
+
+#define INTERFACE_IHasher(x) \
+  STDMETHOD_(void, Init)() throw() x; \
+  STDMETHOD_(void, Update)(const void *data, UInt32 size) throw() x; \
+  STDMETHOD_(void, Final)(Byte *digest) throw() x; \
+  STDMETHOD_(UInt32, GetDigestSize)() throw() x; \
+
+CODER_INTERFACE(IHasher, 0xC0)
+{
+  INTERFACE_IHasher(PURE)
+};
+
+CODER_INTERFACE(IHashers, 0xC1)
+{
+  STDMETHOD_(UInt32, GetNumHashers)() PURE;
+  STDMETHOD(GetHasherProp)(UInt32 index, PROPID propID, PROPVARIANT *value) PURE;
+  STDMETHOD(CreateHasher)(UInt32 index, IHasher **hasher) PURE;
+};
+
+extern "C"
+{
+  typedef HRESULT (WINAPI *Func_GetNumberOfMethods)(UInt32 *numMethods);
+  typedef HRESULT (WINAPI *Func_GetMethodProperty)(UInt32 index, PROPID propID, PROPVARIANT *value);
+  typedef HRESULT (WINAPI *Func_CreateDecoder)(UInt32 index, const GUID *iid, void **outObject);
+  typedef HRESULT (WINAPI *Func_CreateEncoder)(UInt32 index, const GUID *iid, void **outObject);
+
+  typedef HRESULT (WINAPI *Func_GetHashers)(IHashers **hashers);
+  
+  typedef HRESULT (WINAPI *Func_SetCodecs)(ICompressCodecsInfo *compressCodecsInfo);
+}
+
 #endif