AES zip decryption works

2026-09-24 07:54:39 +00:00 · 2013-07-27 12:06:54 +01:00
parent 9cf8c1a747
commit 404fa8c62d
20 changed files with 4823 additions and 34 deletions
--- a/SharpCompress.Test/SharpCompress.Test.Portable.csproj
+++ b/SharpCompress.Test/SharpCompress.Test.Portable.csproj
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{E9C3C94B-FB27-4B4F-B225-57513C254D37}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>SharpCompress.Test</RootNamespace>
+    <AssemblyName>SharpCompress.Test</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <FileAlignment>512</FileAlignment>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\sharpcompress\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject>
+    </StartupObject>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>..\SharpCompress\SharpCompress.pfx</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ArchiveTests.cs" />
+    <Compile Include="GZip\GZipWriterTests.cs" />
+    <Compile Include="GZip\GZipArchiveTests.cs" />
+    <Compile Include="Rar\RarHeaderFactoryTest.cs" />
+    <Compile Include="SevenZip\SevenZipArchiveTests.cs" />
+    <Compile Include="Streams\StreamTests.cs" />
+    <Compile Include="Tar\TarWriterTests.cs" />
+    <Compile Include="Tar\TarReaderTests.cs" />
+    <Compile Include="Zip\ZipWriterTests.cs" />
+    <Compile Include="WriterTests.cs" />
+    <Compile Include="Rar\RarReaderTests.cs" />
+    <Compile Include="ReaderTests.cs" />
+    <Compile Include="Tar\TarArchiveTests.cs" />
+    <Compile Include="Zip\ZipArchiveTests.cs" />
+    <Compile Include="Rar\RarArchiveTests.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RewindableStreamTest.cs" />
+    <Compile Include="TestBase.cs" />
+    <Compile Include="TestStream.cs" />
+    <Compile Include="Zip\ZipReaderTests.cs" />
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+      <DesignTime>True</DesignTime>
+    </Compile>
+    <None Include="..\SharpCompress\SharpCompress.pfx">
+      <Link>SharpCompress.pfx</Link>
+    </None>
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\SharpCompress\SharpCompress.PortableTest.csproj">
+      <Project>{efdcaf57-fd4d-4e5d-a3d5-f26b875817ed}</Project>
+      <Name>SharpCompress.PortableTest</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
--- a/SharpCompress.sln
+++ b/SharpCompress.sln
@@ -9,6 +9,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpCompress.Portable", "S
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpCompress.WindowsStore", "SharpCompress\SharpCompress.WindowsStore.csproj", "{1DF6D83C-31FF-47B6-82FE-C4603BE916B5}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpCompress.PortableTest", "SharpCompress\SharpCompress.PortableTest.csproj", "{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpCompress.Test.Portable", "SharpCompress.Test\SharpCompress.Test.Portable.csproj", "{E9C3C94B-FB27-4B4F-B225-57513C254D37}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Testing", "Testing", "{932BBFCC-76E3-45FF-90CA-6BE4FBF4A097}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -67,8 +73,33 @@ Global
 		{1DF6D83C-31FF-47B6-82FE-C4603BE916B5}.Release|x64.Build.0 = Release|x64
 		{1DF6D83C-31FF-47B6-82FE-C4603BE916B5}.Release|x86.ActiveCfg = Release|x86
 		{1DF6D83C-31FF-47B6-82FE-C4603BE916B5}.Release|x86.Build.0 = Release|x86
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Release|ARM.ActiveCfg = Release|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Release|x64.ActiveCfg = Release|Any CPU
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}.Release|x86.ActiveCfg = Release|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Release|ARM.ActiveCfg = Release|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Release|x64.ActiveCfg = Release|Any CPU
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED} = {932BBFCC-76E3-45FF-90CA-6BE4FBF4A097}
+		{15679D7A-F22C-4943-87FF-BF5C76C4A6FD} = {932BBFCC-76E3-45FF-90CA-6BE4FBF4A097}
+		{E9C3C94B-FB27-4B4F-B225-57513C254D37} = {932BBFCC-76E3-45FF-90CA-6BE4FBF4A097}
+	EndGlobalSection
 EndGlobal
--- a/SharpCompress/Common/Zip/WinzipAesCryptoStream.Portable.cs
+++ b/SharpCompress/Common/Zip/WinzipAesCryptoStream.Portable.cs
@@ -0,0 +1,170 @@
+using System;
+using System.IO;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Parameters;
+
+namespace SharpCompress.Common.Zip
+{
+    internal class WinzipAesCryptoStream : Stream
+    {
+        private const int BLOCK_SIZE_IN_BYTES = 16;
+        private readonly IBufferedCipher rijndael;
+        private readonly byte[] counter = new byte[BLOCK_SIZE_IN_BYTES];
+        private readonly Stream stream;
+        private int nonce = 1;
+        private byte[] counterOut = new byte[BLOCK_SIZE_IN_BYTES];
+        private bool isFinalBlock;
+        private long totalBytesLeftToRead;
+        private bool isDisposed;
+
+        internal WinzipAesCryptoStream(Stream stream, WinzipAesEncryptionData winzipAesEncryptionData, long length)
+        {
+            this.stream = stream;
+            totalBytesLeftToRead = length;
+
+            rijndael = CreateRijndael(winzipAesEncryptionData);
+        }
+
+        private IBufferedCipher CreateRijndael(WinzipAesEncryptionData winzipAesEncryptionData)
+        {
+            var blockCipher = new BufferedBlockCipher(new RijndaelEngine());
+            var param = new KeyParameter(winzipAesEncryptionData.KeyBytes);
+            blockCipher.Init(true, param);
+            return blockCipher;
+        }
+
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return false; }
+        }
+
+        public override long Length
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        public override long Position
+        {
+            get { throw new NotImplementedException(); }
+            set { throw new NotImplementedException(); }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (isDisposed)
+            {
+                return;
+            }
+            isDisposed = true;
+            if (disposing)
+            {
+                //read out last 10 auth bytes
+                var ten = new byte[10];
+                stream.Read(ten, 0, 10);
+                stream.Dispose();
+            }
+        }
+
+        public override void Flush()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (totalBytesLeftToRead == 0)
+            {
+                return 0;
+            }
+            int bytesToRead = count;
+            if (count > totalBytesLeftToRead)
+            {
+                bytesToRead = (int)totalBytesLeftToRead;
+            }
+            int read = stream.Read(buffer, offset, bytesToRead);
+            totalBytesLeftToRead -= read;
+
+            ReadTransformBlocks(buffer, offset, read);
+
+            return read;
+        }
+
+        private int ReadTransformOneBlock(byte[] buffer, int offset, int last)
+        {
+            if (isFinalBlock)
+            {
+                throw new InvalidOperationException();
+            }
+
+            int bytesRemaining = last - offset;
+            int bytesToRead = (bytesRemaining > BLOCK_SIZE_IN_BYTES)
+                                  ? BLOCK_SIZE_IN_BYTES
+                                  : bytesRemaining;
+
+            // update the counter
+            Array.Copy(BitConverter.GetBytes(nonce++), 0, counter, 0, 4);
+
+            // Determine if this is the final block
+            if ((bytesToRead == bytesRemaining) && (totalBytesLeftToRead == 0))
+            {
+                counterOut = rijndael.DoFinal(counter, 0, BLOCK_SIZE_IN_BYTES);
+
+                isFinalBlock = true;
+            }
+            else
+            {
+                rijndael.ProcessBytes(counter, 0, BLOCK_SIZE_IN_BYTES, counterOut, 0);
+            }
+            XorInPlace(buffer, offset, bytesToRead);
+            return bytesToRead;
+        }
+
+
+        private void XorInPlace(byte[] buffer, int offset, int count)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                buffer[offset + i] = (byte)(counterOut[i] ^ buffer[offset + i]);
+            }
+        }
+
+        private void ReadTransformBlocks(byte[] buffer, int offset, int count)
+        {
+            int posn = offset;
+            int last = count + offset;
+
+            while (posn < buffer.Length && posn < last)
+            {
+                int n = ReadTransformOneBlock(buffer, posn, last);
+                posn += n;
+            }
+        }
+
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
--- a/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs
+++ b/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs
@@ -9,49 +9,33 @@ namespace SharpCompress.Common.Zip
        private const int BLOCK_SIZE_IN_BYTES = 16;
        private readonly SymmetricAlgorithm cipher;
        private readonly byte[] counter = new byte[BLOCK_SIZE_IN_BYTES];
-        private readonly HMACSHA1 hmac;
        private readonly Stream stream;
        private readonly ICryptoTransform transform;
-        private int _nonce = 1;
+        private int nonce = 1;
        private byte[] counterOut = new byte[BLOCK_SIZE_IN_BYTES];
        private bool isFinalBlock;
-        private CryptoMode mode;
        private long totalBytesLeftToRead;
        private bool isDisposed;

-        internal WinzipAesCryptoStream(Stream stream, WinzipAesEncryptionData winzipAesEncryptionData, long length,
-                                       CryptoMode mode)
+        internal WinzipAesCryptoStream(Stream stream, WinzipAesEncryptionData winzipAesEncryptionData, long length)
        {
-            this.mode = mode;
            this.stream = stream;
            totalBytesLeftToRead = length;

-            hmac = new HMACSHA1(winzipAesEncryptionData.IvBytes);
-
            cipher = CreateCipher(winzipAesEncryptionData);

            var iv = new byte[BLOCK_SIZE_IN_BYTES];
            transform = cipher.CreateEncryptor(winzipAesEncryptionData.KeyBytes, iv);
-
-            //if (_mode == CryptoMode.Encrypt)
-            //{
-            //    _iobuf = new byte[2048];
-            //    _PendingWriteBlock = new byte[BLOCK_SIZE_IN_BYTES];
-            //}
        }

        private SymmetricAlgorithm CreateCipher(WinzipAesEncryptionData winzipAesEncryptionData)
        {
-#if !PORTABLE
            RijndaelManaged cipher = new RijndaelManaged();
            cipher.BlockSize = BLOCK_SIZE_IN_BYTES * 8;
            cipher.KeySize = winzipAesEncryptionData.KeyBytes.Length * 8;
            cipher.Mode = CipherMode.ECB;
            cipher.Padding = PaddingMode.None;
            return cipher;
-#else
-            throw new NotSupportedException("Cannot decrypt Winzip AES with Silverlight or WP7.");
-#endif
        }

        public override bool CanRead
@@ -133,12 +117,11 @@ namespace SharpCompress.Common.Zip
                                  : bytesRemaining;

            // update the counter
-            Array.Copy(BitConverter.GetBytes(_nonce++), 0, counter, 0, 4);
+            Array.Copy(BitConverter.GetBytes(nonce++), 0, counter, 0, 4);

            // Determine if this is the final block
            if ((bytesToRead == bytesRemaining) && (totalBytesLeftToRead == 0))
            {
-                hmac.TransformFinalBlock(buffer, offset, bytesToRead);
                counterOut = transform.TransformFinalBlock(counter,
                                                           0,
                                                           BLOCK_SIZE_IN_BYTES);
@@ -146,7 +129,6 @@ namespace SharpCompress.Common.Zip
            }
            else
            {
-                hmac.TransformBlock(buffer, offset, bytesToRead, null, 0);
                transform.TransformBlock(counter,
                                         0, // offset
                                         BLOCK_SIZE_IN_BYTES,
--- a/SharpCompress/Common/Zip/WinzipAesEncryptionData.Portable.cs
+++ b/SharpCompress/Common/Zip/WinzipAesEncryptionData.Portable.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Text;
+using SharpCompress.Crypto;
+
+namespace SharpCompress.Common.Zip
+{
+    internal class WinzipAesEncryptionData
+    {
+        private const int RFC2898_ITERATIONS = 1000;
+
+        private byte[] salt;
+        private WinzipAesKeySize keySize;
+        private byte[] passwordVerifyValue;
+        private string password;
+
+        private byte[] generatedVerifyValue;
+
+        internal WinzipAesEncryptionData(WinzipAesKeySize keySize, byte[] salt, byte[] passwordVerifyValue,
+                                         string password)
+        {
+            this.keySize = keySize;
+            this.salt = salt;
+            this.passwordVerifyValue = passwordVerifyValue;
+            this.password = password;
+            Initialize();
+        }
+
+        internal byte[] IvBytes { get; set; }
+        internal byte[] KeyBytes { get; set; }
+
+        private int KeySizeInBytes
+        {
+            get { return KeyLengthInBytes(keySize); }
+        }
+
+        internal static int KeyLengthInBytes(WinzipAesKeySize keySize)
+        {
+            switch (keySize)
+            {
+                case WinzipAesKeySize.KeySize128:
+                    return 16;
+                case WinzipAesKeySize.KeySize192:
+                    return 24;
+                case WinzipAesKeySize.KeySize256:
+                    return 32;
+            }
+            throw new InvalidOperationException();
+        }
+
+        private void Initialize()
+        {
+            var utf8 = new UTF8Encoding(false);
+            var paramz = new PBKDF2(utf8.GetBytes(password), salt, RFC2898_ITERATIONS);
+            KeyBytes = paramz.GetBytes(KeySizeInBytes);
+            IvBytes = paramz.GetBytes(KeySizeInBytes);
+            generatedVerifyValue = paramz.GetBytes(2);
+
+
+            short verify = BitConverter.ToInt16(passwordVerifyValue, 0);
+            if (password != null)
+            {
+                short generated = BitConverter.ToInt16(generatedVerifyValue, 0);
+                if (verify != generated)
+                    throw new InvalidFormatException("bad password");
+            }
+        }
+    }
+}
--- a/SharpCompress/Common/Zip/ZipFilePart.cs
+++ b/SharpCompress/Common/Zip/ZipFilePart.cs
@@ -89,7 +89,7 @@ namespace SharpCompress.Common.Zip
                                              Header.CompressedSize > 0 ? Header.CompressedSize - 4 - props.Length : -1,
                                              FlagUtility.HasFlag(Header.Flags, HeaderFlags.Bit1)
                                                  ? -1
-                                                  : (long) Header.UncompressedSize);
+                                                  : (long)Header.UncompressedSize);
                    }
                case ZipCompressionMethod.PPMd:
                    {
@@ -120,7 +120,7 @@ namespace SharpCompress.Common.Zip
                        {
                            throw new InvalidFormatException("Unexpected vendor ID for WinZip AES metadata");
                        }
-                        Header.CompressionMethod = (ZipCompressionMethod) BitConverter.ToUInt16(data.DataBytes, 5);
+                        Header.CompressionMethod = (ZipCompressionMethod)BitConverter.ToUInt16(data.DataBytes, 5);
                        return CreateDecompressionStream(stream);
                    }
                default:
@@ -134,7 +134,7 @@ namespace SharpCompress.Common.Zip
        {
            if ((Header.CompressedSize == 0)
 #if !PORTABLE && !NETFX_CORE
-                && ((Header.PkwareTraditionalEncryptionData != null)
+ && ((Header.PkwareTraditionalEncryptionData != null)
                    || (Header.WinzipAesEncryptionData != null)))
 #else 
                && (Header.PkwareTraditionalEncryptionData != null))
@@ -160,8 +160,7 @@ namespace SharpCompress.Common.Zip
            if (Header.WinzipAesEncryptionData != null)
            {
                //only read 10 less because the last ten are auth bytes
-                return new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData,
-                                                 Header.CompressedSize - 10, CryptoMode.Decrypt);
+                return new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData, Header.CompressedSize - 10);
            }
 #endif
            return plainStream;
--- a/SharpCompress/Crypto/BigInteger.cs
+++ b/SharpCompress/Crypto/BigInteger.cs
--- a/SharpCompress/Crypto/BufferedBlockCipher.cs
+++ b/SharpCompress/Crypto/BufferedBlockCipher.cs
@@ -0,0 +1,376 @@
+using System;
+
+
+namespace Org.BouncyCastle.Crypto
+{
+    /**
+    * A wrapper class that allows block ciphers to be used to process data in
+    * a piecemeal fashion. The BufferedBlockCipher outputs a block only when the
+    * buffer is full and more data is being added, or on a doFinal.
+    * <p>
+    * Note: in the case where the underlying cipher is either a CFB cipher or an
+    * OFB one the last block may not be a multiple of the block size.
+    * </p>
+    */
+    public class BufferedBlockCipher
+        : BufferedCipherBase
+    {
+        internal byte[] buf;
+        internal int bufOff;
+        internal bool forEncryption;
+        internal IBlockCipher cipher;
+
+        /**
+        * constructor for subclasses
+        */
+        protected BufferedBlockCipher()
+        {
+        }
+
+        /**
+        * Create a buffered block cipher without padding.
+        *
+        * @param cipher the underlying block cipher this buffering object wraps.
+        * false otherwise.
+        */
+        public BufferedBlockCipher(
+            IBlockCipher cipher)
+        {
+            if (cipher == null)
+                throw new ArgumentNullException("cipher");
+
+            this.cipher = cipher;
+            buf = new byte[cipher.GetBlockSize()];
+            bufOff = 0;
+        }
+
+        public override string AlgorithmName
+        {
+            get { return cipher.AlgorithmName; }
+        }
+
+        /**
+        * initialise the cipher.
+        *
+        * @param forEncryption if true the cipher is initialised for
+        *  encryption, if false for decryption.
+        * @param param the key and other data required by the cipher.
+        * @exception ArgumentException if the parameters argument is
+        * inappropriate.
+        */
+        // Note: This doubles as the Init in the event that this cipher is being used as an IWrapper
+        public override void Init(
+            bool forEncryption,
+            ICipherParameters parameters)
+        {
+            this.forEncryption = forEncryption;
+
+            //if (parameters is ParametersWithRandom)
+            //{
+            //    parameters = ((ParametersWithRandom) parameters).Parameters;
+            //}
+
+            Reset();
+
+            cipher.Init(forEncryption, parameters);
+        }
+
+        /**
+        * return the blocksize for the underlying cipher.
+        *
+        * @return the blocksize for the underlying cipher.
+        */
+        public override int GetBlockSize()
+        {
+            return cipher.GetBlockSize();
+        }
+
+        /**
+        * return the size of the output buffer required for an update
+        * an input of len bytes.
+        *
+        * @param len the length of the input.
+        * @return the space required to accommodate a call to update
+        * with len bytes of input.
+        */
+        public override int GetUpdateOutputSize(
+            int length)
+        {
+            int total = length + bufOff;
+            int leftOver = total % buf.Length;
+            return total - leftOver;
+        }
+
+        /**
+        * return the size of the output buffer required for an update plus a
+        * doFinal with an input of len bytes.
+        *
+        * @param len the length of the input.
+        * @return the space required to accommodate a call to update and doFinal
+        * with len bytes of input.
+        */
+        public override int GetOutputSize(
+            int length)
+        {
+            // Note: Can assume IsPartialBlockOkay is true for purposes of this calculation
+            return length + bufOff;
+        }
+
+        /**
+        * process a single byte, producing an output block if neccessary.
+        *
+        * @param in the input byte.
+        * @param out the space for any output that might be produced.
+        * @param outOff the offset from which the output will be copied.
+        * @return the number of output bytes copied to out.
+        * @exception DataLengthException if there isn't enough space in out.
+        * @exception InvalidOperationException if the cipher isn't initialised.
+        */
+        public override int ProcessByte(
+            byte input,
+            byte[] output,
+            int outOff)
+        {
+            buf[bufOff++] = input;
+
+            if (bufOff == buf.Length)
+            {
+                if ((outOff + buf.Length) > output.Length)
+                    throw new DataLengthException("output buffer too short");
+
+                bufOff = 0;
+                return cipher.ProcessBlock(buf, 0, output, outOff);
+            }
+
+            return 0;
+        }
+
+        public override byte[] ProcessByte(
+            byte input)
+        {
+            int outLength = GetUpdateOutputSize(1);
+
+            byte[] outBytes = outLength > 0 ? new byte[outLength] : null;
+
+            int pos = ProcessByte(input, outBytes, 0);
+
+            if (outLength > 0 && pos < outLength)
+            {
+                byte[] tmp = new byte[pos];
+                Array.Copy(outBytes, 0, tmp, 0, pos);
+                outBytes = tmp;
+            }
+
+            return outBytes;
+        }
+
+        public override byte[] ProcessBytes(
+            byte[] input,
+            int inOff,
+            int length)
+        {
+            if (input == null)
+                throw new ArgumentNullException("input");
+            if (length < 1)
+                return null;
+
+            int outLength = GetUpdateOutputSize(length);
+
+            byte[] outBytes = outLength > 0 ? new byte[outLength] : null;
+
+            int pos = ProcessBytes(input, inOff, length, outBytes, 0);
+
+            if (outLength > 0 && pos < outLength)
+            {
+                byte[] tmp = new byte[pos];
+                Array.Copy(outBytes, 0, tmp, 0, pos);
+                outBytes = tmp;
+            }
+
+            return outBytes;
+        }
+
+        /**
+        * process an array of bytes, producing output if necessary.
+        *
+        * @param in the input byte array.
+        * @param inOff the offset at which the input data starts.
+        * @param len the number of bytes to be copied out of the input array.
+        * @param out the space for any output that might be produced.
+        * @param outOff the offset from which the output will be copied.
+        * @return the number of output bytes copied to out.
+        * @exception DataLengthException if there isn't enough space in out.
+        * @exception InvalidOperationException if the cipher isn't initialised.
+        */
+        public override int ProcessBytes(
+            byte[] input,
+            int inOff,
+            int length,
+            byte[] output,
+            int outOff)
+        {
+            if (length < 1)
+            {
+                if (length < 0)
+                    throw new ArgumentException("Can't have a negative input length!");
+
+                return 0;
+            }
+
+            int blockSize = GetBlockSize();
+            int outLength = GetUpdateOutputSize(length);
+
+            if (outLength > 0)
+            {
+                if ((outOff + outLength) > output.Length)
+                {
+                    throw new DataLengthException("output buffer too short");
+                }
+            }
+
+            int resultLen = 0;
+            int gapLen = buf.Length - bufOff;
+            if (length > gapLen)
+            {
+                Array.Copy(input, inOff, buf, bufOff, gapLen);
+                resultLen += cipher.ProcessBlock(buf, 0, output, outOff);
+                bufOff = 0;
+                length -= gapLen;
+                inOff += gapLen;
+                while (length > buf.Length)
+                {
+                    resultLen += cipher.ProcessBlock(input, inOff, output, outOff + resultLen);
+                    length -= blockSize;
+                    inOff += blockSize;
+                }
+            }
+            Array.Copy(input, inOff, buf, bufOff, length);
+            bufOff += length;
+            if (bufOff == buf.Length)
+            {
+                resultLen += cipher.ProcessBlock(buf, 0, output, outOff + resultLen);
+                bufOff = 0;
+            }
+            return resultLen;
+        }
+
+        public override byte[] DoFinal()
+        {
+            byte[] outBytes = EmptyBuffer;
+
+            int length = GetOutputSize(0);
+            if (length > 0)
+            {
+                outBytes = new byte[length];
+
+                int pos = DoFinal(outBytes, 0);
+                if (pos < outBytes.Length)
+                {
+                    byte[] tmp = new byte[pos];
+                    Array.Copy(outBytes, 0, tmp, 0, pos);
+                    outBytes = tmp;
+                }
+            }
+            else
+            {
+                Reset();
+            }
+
+            return outBytes;
+        }
+
+        public override byte[] DoFinal(
+            byte[] input,
+            int inOff,
+            int inLen)
+        {
+            if (input == null)
+                throw new ArgumentNullException("input");
+
+            int length = GetOutputSize(inLen);
+
+            byte[] outBytes = EmptyBuffer;
+
+            if (length > 0)
+            {
+                outBytes = new byte[length];
+
+                int pos = (inLen > 0)
+                    ? ProcessBytes(input, inOff, inLen, outBytes, 0)
+                    : 0;
+
+                pos += DoFinal(outBytes, pos);
+
+                if (pos < outBytes.Length)
+                {
+                    byte[] tmp = new byte[pos];
+                    Array.Copy(outBytes, 0, tmp, 0, pos);
+                    outBytes = tmp;
+                }
+            }
+            else
+            {
+                Reset();
+            }
+
+            return outBytes;
+        }
+
+        /**
+        * Process the last block in the buffer.
+        *
+        * @param out the array the block currently being held is copied into.
+        * @param outOff the offset at which the copying starts.
+        * @return the number of output bytes copied to out.
+        * @exception DataLengthException if there is insufficient space in out for
+        * the output, or the input is not block size aligned and should be.
+        * @exception InvalidOperationException if the underlying cipher is not
+        * initialised.
+        * @exception InvalidCipherTextException if padding is expected and not found.
+        * @exception DataLengthException if the input is not block size
+        * aligned.
+        */
+        public override int DoFinal(
+            byte[] output,
+            int outOff)
+        {
+            try
+            {
+                if (bufOff != 0)
+                {
+                    if (!cipher.IsPartialBlockOkay)
+                    {
+                        throw new DataLengthException("data not block size aligned");
+                    }
+
+                    if (outOff + bufOff > output.Length)
+                    {
+                        throw new DataLengthException("output buffer too short for DoFinal()");
+                    }
+
+                    // NB: Can't copy directly, or we may write too much output
+                    cipher.ProcessBlock(buf, 0, buf, 0);
+                    Array.Copy(buf, 0, output, outOff, bufOff);
+                }
+
+                return bufOff;
+            }
+            finally
+            {
+                Reset();
+            }
+        }
+
+        /**
+        * Reset the buffer and cipher. After resetting the object is in the same
+        * state as it was after the last init (if there was one).
+        */
+        public override void Reset()
+        {
+            Array.Clear(buf, 0, buf.Length);
+            bufOff = 0;
+
+            cipher.Reset();
+        }
+    }
+}
--- a/SharpCompress/Crypto/BufferedCipherBase.cs
+++ b/SharpCompress/Crypto/BufferedCipherBase.cs
@@ -0,0 +1,113 @@
+using System;
+
+namespace Org.BouncyCastle.Crypto
+{
+	public abstract class BufferedCipherBase
+		: IBufferedCipher
+	{
+		protected static readonly byte[] EmptyBuffer = new byte[0];
+
+		public abstract string AlgorithmName { get; }
+
+		public abstract void Init(bool forEncryption, ICipherParameters parameters);
+
+		public abstract int GetBlockSize();
+
+		public abstract int GetOutputSize(int inputLen);
+		public abstract int GetUpdateOutputSize(int inputLen);
+
+		public abstract byte[] ProcessByte(byte input);
+
+		public virtual int ProcessByte(
+			byte	input,
+			byte[]	output,
+			int		outOff)
+		{
+			byte[] outBytes = ProcessByte(input);
+			if (outBytes == null)
+				return 0;
+			if (outOff + outBytes.Length > output.Length)
+				throw new DataLengthException("output buffer too short");
+			outBytes.CopyTo(output, outOff);
+			return outBytes.Length;
+		}
+
+		public virtual byte[] ProcessBytes(
+			byte[] input)
+		{
+			return ProcessBytes(input, 0, input.Length);
+		}
+
+		public abstract byte[] ProcessBytes(byte[] input, int inOff, int length);
+
+		public virtual int ProcessBytes(
+			byte[]	input,
+			byte[]	output,
+			int		outOff)
+		{
+			return ProcessBytes(input, 0, input.Length, output, outOff);
+		}
+
+		public virtual int ProcessBytes(
+			byte[]	input,
+			int		inOff,
+			int		length,
+			byte[]	output,
+			int		outOff)
+		{
+			byte[] outBytes = ProcessBytes(input, inOff, length);
+			if (outBytes == null)
+				return 0;
+			if (outOff + outBytes.Length > output.Length)
+				throw new DataLengthException("output buffer too short");
+			outBytes.CopyTo(output, outOff);
+			return outBytes.Length;
+		}
+
+		public abstract byte[] DoFinal();
+
+		public virtual byte[] DoFinal(
+			byte[] input)
+		{
+			return DoFinal(input, 0, input.Length);
+		}
+
+		public abstract byte[] DoFinal(
+			byte[]	input,
+			int		inOff,
+			int		length);
+
+		public virtual int DoFinal(
+			byte[]	output,
+			int		outOff)
+		{
+			byte[] outBytes = DoFinal();
+			if (outOff + outBytes.Length > output.Length)
+				throw new DataLengthException("output buffer too short");
+			outBytes.CopyTo(output, outOff);
+			return outBytes.Length;
+		}
+
+		public virtual int DoFinal(
+			byte[]	input,
+			byte[]	output,
+			int		outOff)
+		{
+			return DoFinal(input, 0, input.Length, output, outOff);
+		}
+
+		public virtual int DoFinal(
+			byte[]	input,
+			int		inOff,
+			int		length,
+			byte[]	output,
+			int		outOff)
+		{
+			int len = ProcessBytes(input, inOff, length, output, outOff);
+			len += DoFinal(output, outOff + len);
+			return len;
+		}
+
+		public abstract void Reset();
+	}
+}
--- a/SharpCompress/Crypto/HMac.cs
+++ b/SharpCompress/Crypto/HMac.cs
@@ -0,0 +1,134 @@
+using System;
+using System.Collections;
+
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Parameters;
+
+namespace Org.BouncyCastle.Crypto.Macs
+{
+    /**
+    * HMAC implementation based on RFC2104
+    *
+    * H(K XOR opad, H(K XOR ipad, text))
+    */
+    public class HMac
+		: IMac
+    {
+        private const byte IPAD = (byte)0x36;
+        private const byte OPAD = (byte)0x5C;
+
+        private readonly IDigest digest;
+        private readonly int digestSize;
+        private readonly int blockLength;
+
+		private readonly byte[] inputPad;
+        private readonly byte[] outputPad;
+
+        public HMac(
+            IDigest digest)
+        {
+            this.digest = digest;
+            this.digestSize = digest.GetDigestSize();
+            this.blockLength = digest.GetByteLength();
+            this.inputPad = new byte[blockLength];
+            this.outputPad = new byte[blockLength];
+        }
+
+        public string AlgorithmName
+        {
+            get { return digest.AlgorithmName + "/HMAC"; }
+        }
+
+		public IDigest GetUnderlyingDigest()
+        {
+            return digest;
+        }
+
+        public void Init(
+            ICipherParameters parameters)
+        {
+            digest.Reset();
+
+            byte[] key = ((KeyParameter)parameters).GetKey();
+			int keyLength = key.Length;
+
+            if (keyLength > blockLength)
+            {
+                digest.BlockUpdate(key, 0, key.Length);
+                digest.DoFinal(inputPad, 0);
+
+				keyLength = digestSize;
+            }
+            else
+            {
+				Array.Copy(key, 0, inputPad, 0, keyLength);
+            }
+
+			Array.Clear(inputPad, keyLength, blockLength - keyLength);
+            Array.Copy(inputPad, 0, outputPad, 0, blockLength);
+
+			xor(inputPad, IPAD);
+			xor(outputPad, OPAD);
+
+			// Initialise the digest
+			digest.BlockUpdate(inputPad, 0, inputPad.Length);
+        }
+
+        public int GetMacSize()
+        {
+            return digestSize;
+        }
+
+        public void Update(
+            byte input)
+        {
+            digest.Update(input);
+        }
+
+        public void BlockUpdate(
+            byte[] input,
+            int inOff,
+            int len)
+        {
+            digest.BlockUpdate(input, inOff, len);
+        }
+
+        public int DoFinal(
+            byte[] output,
+            int outOff)
+        {
+            byte[] tmp = new byte[digestSize];
+            digest.DoFinal(tmp, 0);
+
+            digest.BlockUpdate(outputPad, 0, outputPad.Length);
+            digest.BlockUpdate(tmp, 0, tmp.Length);
+
+            int len = digest.DoFinal(output, outOff);
+
+			// Initialise the digest
+            digest.BlockUpdate(inputPad, 0, inputPad.Length);
+
+            return len;
+        }
+
+        /**
+        * Reset the mac generator.
+        */
+        public void Reset()
+        {
+			// Reset underlying digest
+            digest.Reset();
+
+			// Initialise the digest
+            digest.BlockUpdate(inputPad, 0, inputPad.Length);
+        }
+
+		private static void xor(byte[] a, byte n)
+		{
+			for (int i = 0; i < a.Length; ++i)
+            {
+                a[i] ^= n;
+            }
+		}
+    }
+}
--- a/SharpCompress/Crypto/IBlockCipher.cs
+++ b/SharpCompress/Crypto/IBlockCipher.cs
@@ -1,5 +1,4 @@
-using Org.BouncyCastle.Crypto.Parameters;
-
+
 namespace Org.BouncyCastle.Crypto
 {
    /// <remarks>Base interface for a symmetric key block cipher.</remarks>
@@ -11,7 +10,7 @@ namespace Org.BouncyCastle.Crypto
        /// <summary>Initialise the cipher.</summary>
        /// <param name="forEncryption">Initialise for encryption if true, for decryption if false.</param>
        /// <param name="parameters">The key or other data required by the cipher.</param>
-        void Init(bool forEncryption, KeyParameter parameters);
+        void Init(bool forEncryption, ICipherParameters parameters);

        /// <returns>The block size for this cipher, in bytes.</returns>
        int GetBlockSize();
--- a/SharpCompress/Crypto/IBufferedCipher.cs
+++ b/SharpCompress/Crypto/IBufferedCipher.cs
@@ -0,0 +1,44 @@
+using System;
+
+namespace Org.BouncyCastle.Crypto
+{
+	/// <remarks>Block cipher engines are expected to conform to this interface.</remarks>
+    public interface IBufferedCipher
+    {
+		/// <summary>The name of the algorithm this cipher implements.</summary>
+		string AlgorithmName { get; }
+
+		/// <summary>Initialise the cipher.</summary>
+		/// <param name="forEncryption">If true the cipher is initialised for encryption,
+		/// if false for decryption.</param>
+		/// <param name="parameters">The key and other data required by the cipher.</param>
+        void Init(bool forEncryption, ICipherParameters parameters);
+
+		int GetBlockSize();
+
+		int GetOutputSize(int inputLen);
+
+		int GetUpdateOutputSize(int inputLen);
+
+		byte[] ProcessByte(byte input);
+		int ProcessByte(byte input, byte[] output, int outOff);
+
+		byte[] ProcessBytes(byte[] input);
+		byte[] ProcessBytes(byte[] input, int inOff, int length);
+		int ProcessBytes(byte[] input, byte[] output, int outOff);
+		int ProcessBytes(byte[] input, int inOff, int length, byte[] output, int outOff);
+
+		byte[] DoFinal();
+		byte[] DoFinal(byte[] input);
+		byte[] DoFinal(byte[] input, int inOff, int length);
+		int DoFinal(byte[] output, int outOff);
+		int DoFinal(byte[] input, byte[] output, int outOff);
+		int DoFinal(byte[] input, int inOff, int length, byte[] output, int outOff);
+
+		/// <summary>
+		/// Reset the cipher. After resetting the cipher is in the same state
+		/// as it was after the last init (if there was one).
+		/// </summary>
+        void Reset();
+    }
+}
--- a/SharpCompress/Crypto/ICipherParameters.cs
+++ b/SharpCompress/Crypto/ICipherParameters.cs
@@ -1,4 +1,5 @@
-namespace Org.BouncyCastle.Crypto
+
+namespace Org.BouncyCastle.Crypto
 {
    public interface ICipherParameters
    {
--- a/SharpCompress/Crypto/IMac.cs
+++ b/SharpCompress/Crypto/IMac.cs
@@ -0,0 +1,64 @@
+namespace Org.BouncyCastle.Crypto
+{
+    public interface IMac
+    {
+        /**
+         * Initialise the MAC.
+         *
+         * @param param the key and other data required by the MAC.
+         * @exception ArgumentException if the parameters argument is
+         * inappropriate.
+         */
+        void Init(ICipherParameters parameters);
+
+        /**
+         * Return the name of the algorithm the MAC implements.
+         *
+         * @return the name of the algorithm the MAC implements.
+         */
+        string AlgorithmName { get; }
+
+        /**
+         * Return the block size for this MAC (in bytes).
+         *
+         * @return the block size for this MAC in bytes.
+         */
+        int GetMacSize();
+
+        /**
+         * add a single byte to the mac for processing.
+         *
+         * @param in the byte to be processed.
+         * @exception InvalidOperationException if the MAC is not initialised.
+         */
+        void Update(byte input);
+
+        /**
+         * @param in the array containing the input.
+         * @param inOff the index in the array the data begins at.
+         * @param len the length of the input starting at inOff.
+         * @exception InvalidOperationException if the MAC is not initialised.
+         * @exception DataLengthException if there isn't enough data in in.
+         */
+        void BlockUpdate(byte[] input, int inOff, int len);
+
+        /**
+         * Compute the final stage of the MAC writing the output to the out
+         * parameter.
+         * <p>
+         * doFinal leaves the MAC in the same state it was after the last init.
+         * </p>
+         * @param out the array the MAC is to be output to.
+         * @param outOff the offset into the out buffer the output is to start at.
+         * @exception DataLengthException if there isn't enough space in out.
+         * @exception InvalidOperationException if the MAC is not initialised.
+         */
+        int DoFinal(byte[] output, int outOff);
+
+        /**
+         * Reset the MAC. At the end of resetting the MAC should be in the
+         * in the same state it was after the last init (if there was one).
+         */
+        void Reset();
+    }
+}
--- a/SharpCompress/Crypto/PBKDF2.cs
+++ b/SharpCompress/Crypto/PBKDF2.cs
@@ -0,0 +1,119 @@
+using System;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Digests;
+using Org.BouncyCastle.Crypto.Macs;
+using Org.BouncyCastle.Crypto.Parameters;
+
+namespace SharpCompress.Crypto
+{
+    //Gathered from:
+    //http://stackoverflow.com/questions/3210795/pbkdf2-in-bouncy-castle-c-sharp and Rfc2898DeriveBytes 
+    internal class PBKDF2
+    {
+        private readonly IMac hMac = new HMac(new Sha1Digest());
+        private readonly byte[] state = new byte[20];
+        private int endIndex;
+        private int startIndex;
+        private uint block = 1u;
+        private readonly byte[] password;
+        private readonly byte[] salt;
+        private readonly int iterations;
+
+
+        public PBKDF2(byte[] password, byte[] salt, int iterations)
+        {
+            this.password = password;
+            this.salt = salt;
+            this.iterations = iterations;
+        }
+
+        public byte[] GetBytes(int cb)
+        {
+            if (cb <= 0)
+            {
+                throw new ArgumentOutOfRangeException("cb");
+            }
+            byte[] array = new byte[cb];
+            int i = 0;
+            int num = endIndex - startIndex;
+            if (num > 0)
+            {
+                if (cb < num)
+                {
+                    Buffer.BlockCopy(state, startIndex, array, 0, cb);
+                    startIndex += cb;
+                    return array;
+                }
+                Buffer.BlockCopy(state, startIndex, array, 0, num);
+                startIndex = (endIndex = 0);
+                i += num;
+            }
+            while (i < cb)
+            {
+                byte[] src = Hash();
+                int num2 = cb - i;
+                if (num2 <= 20)
+                {
+                    Buffer.BlockCopy(src, 0, array, i, num2);
+                    i += num2;
+                    Buffer.BlockCopy(src, num2, state, startIndex, 20 - num2);
+                    endIndex += 20 - num2;
+                    return array;
+                }
+                Buffer.BlockCopy(src, 0, array, i, 20);
+                i += 20;
+            }
+            return array;
+        }
+
+        private byte[] Hash()
+        {
+            byte[] array = UIntToOctet(block);
+            ICipherParameters param = new KeyParameter(password);
+
+            hMac.Init(param);
+            hMac.BlockUpdate(salt, 0, salt.Length);
+
+            hMac.BlockUpdate(array, 0, array.Length);
+            byte[] array2 = new byte[20];
+            hMac.DoFinal(array2, 0);
+
+            hMac.Init(param);
+
+            byte[] array3 = new byte[20];
+            Buffer.BlockCopy(array2, 0, array3, 0, 20);
+            int num = 2;
+            while (num <= (long)((ulong)iterations))
+            {
+                hMac.BlockUpdate(array2, 0, array2.Length);
+                hMac.DoFinal(array2, 0);
+                for (int i = 0; i < 20; i++)
+                {
+                    array3[i] ^= array2[i];
+                }
+                num++;
+            }
+            block += 1u;
+            return array3;
+        }
+
+        internal static byte[] UIntToOctet(uint i)
+        {
+            byte[] bytes = BitConverter.GetBytes(i);
+            byte[] result = new[]
+                            {
+                                bytes[3],
+                                bytes[2],
+                                bytes[1],
+                                bytes[0]
+                            };
+            if (!BitConverter.IsLittleEndian)
+            {
+                return bytes;
+            }
+            return result;
+        }
+
+    }
+}
+
--- a/SharpCompress/Crypto/RijndaelEngine.cs
+++ b/SharpCompress/Crypto/RijndaelEngine.cs
@@ -566,10 +566,17 @@ namespace Org.BouncyCastle.Crypto.Engines
        */
        public void Init(
            bool forEncryption,
-            KeyParameter parameters)
+            ICipherParameters parameters)
        {
-            workingKey = GenerateWorkingKey(parameters.GetKey());
-            this.forEncryption = forEncryption;
+            var parameter = parameters as KeyParameter;
+            if (parameter != null)
+            {
+                workingKey = GenerateWorkingKey(parameter.GetKey());
+                this.forEncryption = forEncryption;
+                return;
+            }
+
+            throw new ArgumentException("invalid parameter passed to Rijndael init - " + parameters.GetType().ToString());
        }

        public string AlgorithmName
--- a/SharpCompress/SharpCompress.Portable.csproj
+++ b/SharpCompress/SharpCompress.Portable.csproj
@@ -136,6 +136,7 @@
    <Compile Include="Common\Tar\TarReadOnlySubStream.cs" />
    <Compile Include="Common\Tar\TarVolume.cs" />
    <Compile Include="Common\Volume.cs" />
+    <Compile Include="Common\Zip\WinzipAesCryptoStream.Portable.cs" />
    <Compile Include="Common\Zip\Headers\DirectoryEndHeader.cs" />
    <Compile Include="Common\Zip\Headers\DirectoryEntryHeader.cs" />
    <Compile Include="Common\Zip\Headers\HeaderFlags.cs" />
@@ -151,6 +152,8 @@
    <Compile Include="Common\Zip\SeekableZipHeaderFactory.cs" />
    <Compile Include="Common\Zip\StreamingZipFilePart.cs" />
    <Compile Include="Common\Zip\StreamingZipHeaderFactory.cs" />
+    <Compile Include="Common\Zip\WinzipAesEncryptionData.Portable.cs" />
+    <Compile Include="Common\Zip\WinzipAesKeySize.cs" />
    <Compile Include="Common\Zip\ZipCompressionMethod.cs" />
    <Compile Include="Common\Zip\ZipEntry.cs" />
    <Compile Include="Common\Zip\ZipFilePart.cs" />
@@ -256,14 +259,21 @@
    <Compile Include="Compressor\Rar\VM\VMPreparedProgram.cs" />
    <Compile Include="Compressor\Rar\VM\VMStandardFilters.cs" />
    <Compile Include="Compressor\Rar\VM\VMStandardFilterSignature.cs" />
+    <Compile Include="Crypto\BufferedBlockCipher.cs" />
+    <Compile Include="Crypto\BufferedCipherBase.cs" />
    <Compile Include="Crypto\CryptoException.cs" />
    <Compile Include="Crypto\DataLengthException.cs" />
    <Compile Include="Crypto\GeneralDigest.cs" />
+    <Compile Include="Crypto\HMac.cs" />
    <Compile Include="Crypto\IBlockCipher.cs" />
+    <Compile Include="Crypto\IBufferedCipher.cs" />
    <Compile Include="Crypto\ICipherParameters.cs" />
    <Compile Include="Crypto\IDigest.cs" />
+    <Compile Include="Crypto\IMac.cs" />
    <Compile Include="Crypto\KeyParameter.cs" />
+    <Compile Include="Crypto\BigInteger.cs" />
    <Compile Include="Crypto\Pack.cs" />
+    <Compile Include="Crypto\PBKDF2.cs" />
    <Compile Include="Crypto\RijndaelEngine.cs" />
    <Compile Include="Crypto\Sha1Digest.cs" />
    <Compile Include="IO\CountingWritableSubStream.cs" />
--- a/SharpCompress/SharpCompress.PortableTest.csproj
+++ b/SharpCompress/SharpCompress.PortableTest.csproj
@@ -0,0 +1,402 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EFDCAF57-FD4D-4E5D-A3D5-F26B875817ED}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>SharpCompress</RootNamespace>
+    <AssemblyName>SharpCompress</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <StartupObject>
+    </StartupObject>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+    <SccProjectName>
+    </SccProjectName>
+    <SccLocalPath>
+    </SccLocalPath>
+    <SccAuxPath>
+    </SccAuxPath>
+    <SccProvider>
+    </SccProvider>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\sharpcompress\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\bin\</OutputPath>
+    <DefineConstants>TRACE;DEBUG;DISABLE_TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <NoWarn>1591</NoWarn>
+    <DocumentationFile>..\bin\SharpCompress.XML</DocumentationFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <DocumentationFile>..\bin\SharpCompress.xml</DocumentationFile>
+    <NoWarn>1591</NoWarn>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>SharpCompress.pfx</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Common\ArchiveEncoding.cs" />
+    <Compile Include="Archive\AbstractWritableArchive.cs" />
+    <Compile Include="Archive\AbstractArchive.cs" />
+    <Compile Include="Archive\AbstractWritableArchive.Extensions.cs" />
+    <Compile Include="Archive\ArchiveFactory.cs" />
+    <Compile Include="Archive\GZip\GZipWritableArchiveEntry.cs" />
+    <Compile Include="Archive\IArchive.Extensions.cs" />
+    <Compile Include="Archive\GZip\GZipArchive.cs" />
+    <Compile Include="Archive\GZip\GZipArchiveEntry.cs" />
+    <Compile Include="Archive\IArchiveEntry.cs" />
+    <Compile Include="Archive\Rar\RarArchiveEntryFactory.cs" />
+    <Compile Include="Archive\IArchive.cs" />
+    <Compile Include="Archive\Rar\StreamRarArchiveVolume.cs" />
+    <Compile Include="Archive\SevenZip\SevenZipArchive.cs" />
+    <Compile Include="Archive\SevenZip\SevenZipArchiveEntry.cs" />
+    <Compile Include="Archive\Tar\TarArchive.cs" />
+    <Compile Include="Archive\Tar\TarArchiveEntry.cs" />
+    <Compile Include="Archive\Tar\TarWritableArchiveEntry.cs" />
+    <Compile Include="Archive\Zip\ZipWritableArchiveEntry.cs" />
+    <Compile Include="Archive\Zip\ZipArchive.cs" />
+    <Compile Include="Archive\Zip\ZipArchiveEntry.cs" />
+    <Compile Include="Common\ArchiveException.cs" />
+    <Compile Include="Common\ArchiveExtractionEventArgs.cs" />
+    <Compile Include="Common\CompressedBytesReadEventArgs.cs" />
+    <Compile Include="Common\CompressionInfo.cs" />
+    <Compile Include="Common\CompressionType.cs" />
+    <Compile Include="Common\FilePartExtractionBeginEventArgs.cs" />
+    <Compile Include="Common\GenericVolume.cs" />
+    <Compile Include="Common\IncompleteArchiveException.cs" />
+    <Compile Include="Common\MultiVolumeExtractionException.cs" />
+    <Compile Include="Common\PasswordProtectedException.cs" />
+    <Compile Include="Common\CryptographicException.cs" />
+    <Compile Include="Common\FlagUtility.cs" />
+    <Compile Include="Common\GZip\GZipEntry.cs" />
+    <Compile Include="Common\GZip\GZipFilePart.cs" />
+    <Compile Include="Common\GZip\GZipVolume.cs" />
+    <Compile Include="Common\ExtractOptions.cs" />
+    <Compile Include="Common\FilePart.cs" />
+    <Compile Include="Common\Entry.cs" />
+    <Compile Include="Common\IEntry.cs" />
+    <Compile Include="Common\IVolume.cs" />
+    <Compile Include="Common\Rar\RarCryptoWrapper.cs" />
+    <Compile Include="Common\Rar\RarRijndael.Portable.cs" />
+    <Compile Include="Common\SevenZip\CBindPair.cs" />
+    <Compile Include="Common\SevenZip\CCoderInfo.cs" />
+    <Compile Include="Common\SevenZip\CFileItem.cs" />
+    <Compile Include="Common\SevenZip\CFolder.cs" />
+    <Compile Include="Common\SevenZip\CStreamSwitch.cs" />
+    <Compile Include="Common\SevenZip\DataReader.cs" />
+    <Compile Include="Common\SevenZip\SevenZipEntry.cs" />
+    <Compile Include="Common\SevenZip\SevenZipFilePart.cs" />
+    <Compile Include="Common\SevenZip\SevenZipVolume.cs" />
+    <Compile Include="Common\Tar\Headers\TarHeader.cs" />
+    <Compile Include="Common\Tar\TarReadOnlySubStream.cs" />
+    <Compile Include="Common\Tar\TarVolume.cs" />
+    <Compile Include="Common\Tar\TarEntry.cs" />
+    <Compile Include="Common\Tar\TarFilePart.cs" />
+    <Compile Include="Common\Tar\TarHeaderFactory.cs" />
+    <Compile Include="Common\Zip\Headers\HeaderFlags.cs" />
+    <Compile Include="Common\Zip\Headers\IgnoreHeader.cs" />
+    <Compile Include="Common\Zip\Headers\SplitHeader.cs" />
+    <Compile Include="Common\Zip\Headers\ZipFileEntry..cs" />
+    <Compile Include="Common\Zip\Headers\ZipHeaderType.cs" />
+    <Compile Include="Common\Zip\SeekableZipFilePart.cs" />
+    <Compile Include="Common\Zip\SeekableZipHeaderFactory.cs" />
+    <Compile Include="Common\Zip\StreamingZipFilePart.cs" />
+    <Compile Include="Common\Zip\StreamingZipHeaderFactory.cs" />
+    <Compile Include="Common\Zip\WinzipAesCryptoStream.Portable.cs" />
+    <Compile Include="Common\Zip\WinzipAesEncryptionData.Portable.cs" />
+    <Compile Include="Common\Zip\WinzipAesKeySize.cs" />
+    <Compile Include="Common\Zip\ZipVolume.cs" />
+    <Compile Include="Compressor\BZip2\BZip2Constants.cs" />
+    <Compile Include="Compressor\BZip2\BZip2Stream.cs" />
+    <Compile Include="Compressor\BZip2\CBZip2InputStream.cs" />
+    <Compile Include="Compressor\BZip2\CBZip2OutputStream.cs" />
+    <Compile Include="Compressor\BZip2\CRC.cs" />
+    <Compile Include="Compressor\CompressionMode.cs" />
+    <Compile Include="Compressor\Deflate\FlushType.cs" />
+    <Compile Include="Common\Zip\PkwareTraditionalCryptoStream.cs" />
+    <Compile Include="Common\Zip\PkwareTraditionalEncryptionData.cs" />
+    <Compile Include="Compressor\Deflate\GZipStream.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Compressor\Filters\BCJ2Filter.cs" />
+    <Compile Include="Compressor\Filters\BCJFilter.cs" />
+    <Compile Include="Compressor\Filters\Filter.cs" />
+    <Compile Include="Compressor\LZMA\BitVector.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Compressor\LZMA\LZ\CRC.cs" />
+    <Compile Include="Compressor\LZMA\CRC.cs" />
+    <Compile Include="Common\SevenZip\ArchiveDatabase.cs" />
+    <Compile Include="Common\SevenZip\ArchiveReader.cs" />
+    <Compile Include="Common\SevenZip\CMethodId.cs" />
+    <Compile Include="Compressor\LZMA\AesDecoderStream.cs" />
+    <Compile Include="Compressor\LZMA\Bcj2DecoderStream.cs" />
+    <Compile Include="Compressor\LZMA\DecoderStream.cs" />
+    <Compile Include="Compressor\LZMA\Registry.cs" />
+    <Compile Include="Compressor\LZMA\ICoder.cs" />
+    <Compile Include="Compressor\LZMA\Log.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Compressor\LZMA\LzmaBase.cs" />
+    <Compile Include="Compressor\LZMA\LzmaDecoder.cs" />
+    <Compile Include="Compressor\LZMA\LzmaEncoder.cs" />
+    <Compile Include="Compressor\LZMA\LzmaEncoderProperties.cs" />
+    <Compile Include="Compressor\LZMA\LzmaStream.cs" />
+    <Compile Include="Compressor\LZMA\LZ\LzBinTree.cs" />
+    <Compile Include="Compressor\LZMA\LZ\LzInWindow.cs" />
+    <Compile Include="Compressor\LZMA\LZ\LzOutWindow.cs" />
+    <Compile Include="Compressor\LZMA\RangeCoder\RangeCoder.cs" />
+    <Compile Include="Compressor\LZMA\RangeCoder\RangeCoderBit.cs" />
+    <Compile Include="Compressor\LZMA\RangeCoder\RangeCoderBitTree.cs" />
+    <Compile Include="Compressor\LZMA\Utilites\CrcBuilderStream.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Compressor\LZMA\Utilites\CrcCheckStream.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Compressor\LZMA\Utilites\IPasswordProvider.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Compressor\LZMA\Utilites\SyncStreamView.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Compressor\LZMA\Utilites\Utils.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Compressor\PPMd\H\FreqData.cs" />
+    <Compile Include="Compressor\PPMd\H\ModelPPM.cs" />
+    <Compile Include="Compressor\PPMd\H\Pointer.cs" />
+    <Compile Include="Compressor\PPMd\H\PPMContext.cs" />
+    <Compile Include="Compressor\PPMd\H\RangeCoder.cs" />
+    <Compile Include="Compressor\PPMd\H\RarMemBlock.cs" />
+    <Compile Include="Compressor\PPMd\H\RarNode.cs" />
+    <Compile Include="Compressor\PPMd\H\SEE2Context.cs" />
+    <Compile Include="Compressor\PPMd\H\State.cs" />
+    <Compile Include="Compressor\PPMd\H\StateRef.cs" />
+    <Compile Include="Compressor\PPMd\H\SubAllocator.cs" />
+    <Compile Include="Compressor\PPMd\I1\Allocator.cs" />
+    <Compile Include="Compressor\PPMd\I1\Coder.cs" />
+    <Compile Include="Compressor\PPMd\I1\MemoryNode.cs" />
+    <Compile Include="Compressor\PPMd\I1\Model.cs" />
+    <Compile Include="Compressor\PPMd\I1\ModelRestorationMethod.cs" />
+    <Compile Include="Compressor\PPMd\I1\Pointer.cs" />
+    <Compile Include="Compressor\PPMd\I1\PpmContext.cs" />
+    <Compile Include="Compressor\PPMd\I1\PpmState.cs" />
+    <Compile Include="Compressor\PPMd\I1\See2Context.cs" />
+    <Compile Include="Compressor\PPMd\PpmdProperties.cs" />
+    <Compile Include="Compressor\PPMd\PpmdStream.cs" />
+    <Compile Include="Compressor\Rar\RarStream.cs" />
+    <Compile Include="Crypto\BigInteger.cs" />
+    <Compile Include="Crypto\BufferedBlockCipher.cs" />
+    <Compile Include="Crypto\BufferedCipherBase.cs" />
+    <Compile Include="Crypto\CryptoException.cs" />
+    <Compile Include="Crypto\DataLengthException.cs" />
+    <Compile Include="Crypto\GeneralDigest.cs" />
+    <Compile Include="Crypto\HMac.cs" />
+    <Compile Include="Crypto\IBlockCipher.cs" />
+    <Compile Include="Crypto\IBufferedCipher.cs" />
+    <Compile Include="Crypto\ICipherParameters.cs" />
+    <Compile Include="Crypto\IDigest.cs" />
+    <Compile Include="Crypto\IMac.cs" />
+    <Compile Include="Crypto\KeyParameter.cs" />
+    <Compile Include="Crypto\Pack.cs" />
+    <Compile Include="Crypto\PBKDF2.cs" />
+    <Compile Include="Crypto\RijndaelEngine.cs" />
+    <Compile Include="Crypto\Sha1Digest.cs" />
+    <Compile Include="IO\CountingWritableSubStream.cs" />
+    <Compile Include="Common\EntryStream.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="IO\ListeningStream.cs" />
+    <Compile Include="IO\NonDisposingStream.cs" />
+    <Compile Include="Common\Rar\RarCryptoBinaryReader.cs" />
+    <Compile Include="IO\RewindableStream.cs" />
+    <Compile Include="Reader\GZip\GZipReader.cs" />
+    <Compile Include="Reader\ReaderFactory.cs" />
+    <Compile Include="Reader\AbstractReader.cs" />
+    <Compile Include="Common\Volume.cs" />
+    <Compile Include="Compressor\Deflate\CRC32.cs" />
+    <Compile Include="Compressor\Deflate\DeflateManager.cs" />
+    <Compile Include="Compressor\Deflate\DeflateStream.cs" />
+    <Compile Include="Compressor\Deflate\Inflate.cs" />
+    <Compile Include="Compressor\Deflate\InfTree.cs" />
+    <Compile Include="Compressor\Deflate\Tree.cs" />
+    <Compile Include="Compressor\Deflate\Zlib.cs" />
+    <Compile Include="Compressor\Deflate\ZlibBaseStream.cs" />
+    <Compile Include="Compressor\Deflate\ZlibCodec.cs" />
+    <Compile Include="Compressor\Deflate\ZlibConstants.cs" />
+    <Compile Include="Compressor\Deflate\ZlibStream.cs" />
+    <Compile Include="Common\Rar\Headers\FileNameDecoder.cs" />
+    <Compile Include="Common\InvalidFormatException.cs" />
+    <Compile Include="IO\ReadOnlySubStream.cs" />
+    <Compile Include="IO\StreamingMode.cs" />
+    <Compile Include="Common\IStreamListener.cs" />
+    <Compile Include="Common\MultipartStreamRequiredException.cs" />
+    <Compile Include="LazyReadOnlyCollection.cs" />
+    <Compile Include="Archive\Rar\RarArchive.Extensions.cs" />
+    <Compile Include="Archive\IArchiveEntry.Extensions.cs" />
+    <Compile Include="Archive\Rar\RarArchiveEntry.cs" />
+    <Compile Include="Common\ExtractionException.cs" />
+    <Compile Include="Common\Rar\RarEntry.cs" />
+    <Compile Include="Common\Options.cs" />
+    <Compile Include="Reader\IReader.cs" />
+    <Compile Include="Reader\Rar\MultiVolumeRarReader.cs" />
+    <Compile Include="Reader\Rar\RarReader.cs" />
+    <Compile Include="Reader\IReader.Extensions.cs" />
+    <Compile Include="Reader\Rar\RarReaderEntry.cs" />
+    <Compile Include="Archive\Rar\SeekableStreamFilePart.cs" />
+    <Compile Include="Reader\Rar\SingleVolumeRarReader.cs" />
+    <Compile Include="Common\ArchiveType.cs" />
+    <Compile Include="Reader\Tar\TarReader.cs" />
+    <Compile Include="ReadOnlyCollection.cs" />
+    <Compile Include="VersionInfo.cs" />
+    <Compile Include="Archive\Rar\FileInfoRarFilePart.cs" />
+    <Compile Include="Archive\Rar\FileInfoRarArchiveVolume.cs" />
+    <Compile Include="Common\Rar\RarFilePart.cs" />
+    <Compile Include="Common\Rar\Headers\AVHeader.cs" />
+    <Compile Include="Common\Rar\Headers\CommentHeader.cs" />
+    <Compile Include="Common\Rar\Headers\EndArchiveHeader.cs" />
+    <Compile Include="Common\Rar\Headers\SignHeader.cs" />
+    <Compile Include="Common\Rar\RarVolume.cs" />
+    <Compile Include="Compressor\Rar\UnpackUtility.cs" />
+    <Compile Include="Archive\Rar\RarArchive.cs" />
+    <Compile Include="Compressor\Rar\MultiVolumeReadOnlyStream.cs" />
+    <Compile Include="Compressor\Rar\RarCRC.cs" />
+    <Compile Include="Common\Rar\Headers\FileHeader.cs" />
+    <Compile Include="Common\Rar\Headers\ArchiveHeader.cs" />
+    <Compile Include="Common\Rar\Headers\RarHeader.cs" />
+    <Compile Include="IO\MarkingBinaryReader.cs" />
+    <Compile Include="Common\Rar\Headers\NewSubHeader.cs" />
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="Common\Rar\Headers\RarHeaderFactory.cs" />
+    <Compile Include="Common\Rar\Headers\Flags.cs" />
+    <Compile Include="Compressor\Rar\Decode\AudioVariables.cs" />
+    <Compile Include="Compressor\Rar\Decode\BitDecode.cs" />
+    <Compile Include="Compressor\Rar\Decode\CodeType.cs" />
+    <Compile Include="Compressor\Rar\Decode\Compress.cs" />
+    <Compile Include="Compressor\Rar\Decode\Decode.cs" />
+    <Compile Include="Compressor\Rar\Decode\DistDecode.cs" />
+    <Compile Include="Compressor\Rar\Decode\FilterType.cs" />
+    <Compile Include="Compressor\Rar\Decode\LitDecode.cs" />
+    <Compile Include="Compressor\Rar\Decode\LowDistDecode.cs" />
+    <Compile Include="Compressor\Rar\Decode\MultDecode.cs" />
+    <Compile Include="Compressor\Rar\Decode\RepDecode.cs" />
+    <Compile Include="Compressor\Rar\PPM\BlockTypes.cs" />
+    <Compile Include="Compressor\Rar\Unpack.cs" />
+    <Compile Include="Compressor\Rar\Unpack15.cs" />
+    <Compile Include="Compressor\Rar\Unpack20.cs" />
+    <Compile Include="Compressor\Rar\UnpackFilter.cs" />
+    <Compile Include="Compressor\Rar\VM\BitInput.cs" />
+    <Compile Include="Compressor\Rar\VM\RarVM.cs" />
+    <Compile Include="Compressor\Rar\VM\VMCmdFlags.cs" />
+    <Compile Include="Compressor\Rar\VM\VMCommands.cs" />
+    <Compile Include="Compressor\Rar\VM\VMFlags.cs" />
+    <Compile Include="Compressor\Rar\VM\VMOpType.cs" />
+    <Compile Include="Compressor\Rar\VM\VMPreparedCommand.cs" />
+    <Compile Include="Compressor\Rar\VM\VMPreparedOperand.cs" />
+    <Compile Include="Compressor\Rar\VM\VMPreparedProgram.cs" />
+    <Compile Include="Compressor\Rar\VM\VMStandardFilters.cs" />
+    <Compile Include="Compressor\Rar\VM\VMStandardFilterSignature.cs" />
+    <Compile Include="Utility.cs" />
+    <Compile Include="Common\Rar\Headers\MarkHeader.cs" />
+    <Compile Include="Archive\Rar\RarArchiveVolumeFactory.cs" />
+    <Compile Include="Reader\Rar\NonSeekableStreamFilePart.cs" />
+    <Compile Include="Reader\Rar\RarReaderVolume.cs" />
+    <Compile Include="Common\Zip\ZipCompressionMethod.cs" />
+    <Compile Include="Common\Zip\Headers\DirectoryEndHeader.cs" />
+    <Compile Include="Common\Zip\Headers\DirectoryEntryHeader.cs" />
+    <Compile Include="Common\Zip\Headers\LocalEntryHeader.cs" />
+    <Compile Include="Common\Zip\ZipFilePart.cs" />
+    <Compile Include="Common\Zip\Headers\ZipHeader.cs" />
+    <Compile Include="Common\Zip\ZipHeaderFactory.cs" />
+    <Compile Include="Reader\Zip\ZipReader.cs" />
+    <Compile Include="Common\Zip\ZipEntry.cs" />
+    <Compile Include="Writer\AbstractWriter.cs" />
+    <Compile Include="Writer\GZip\GZipWriter.cs" />
+    <Compile Include="Writer\IWriter.Extensions.cs" />
+    <Compile Include="Writer\IWriter.cs" />
+    <Compile Include="Writer\Tar\TarWriter.cs" />
+    <Compile Include="Writer\WriterFactory.cs" />
+    <Compile Include="Writer\Zip\ZipCentralDirectoryEntry.cs" />
+    <Compile Include="Writer\Zip\ZipWriter.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="SharpCompress.pfx" />
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
--- a/SharpCompress/SharpCompress.WindowsStore.csproj
+++ b/SharpCompress/SharpCompress.WindowsStore.csproj
@@ -207,6 +207,9 @@
    <Compile Include="Common\Zip\SeekableZipHeaderFactory.cs" />
    <Compile Include="Common\Zip\StreamingZipFilePart.cs" />
    <Compile Include="Common\Zip\StreamingZipHeaderFactory.cs" />
+    <Compile Include="Common\Zip\WinzipAesCryptoStream.Portable.cs" />
+    <Compile Include="Common\Zip\WinzipAesEncryptionData.Portable.cs" />
+    <Compile Include="Common\Zip\WinzipAesKeySize.cs" />
    <Compile Include="Common\Zip\ZipCompressionMethod.cs" />
    <Compile Include="Common\Zip\ZipEntry.cs" />
    <Compile Include="Common\Zip\ZipFilePart.cs" />
@@ -312,13 +315,20 @@
    <Compile Include="Compressor\Rar\VM\VMPreparedProgram.cs" />
    <Compile Include="Compressor\Rar\VM\VMStandardFilters.cs" />
    <Compile Include="Compressor\Rar\VM\VMStandardFilterSignature.cs" />
+    <Compile Include="Crypto\BigInteger.cs" />
+    <Compile Include="Crypto\BufferedBlockCipher.cs" />
+    <Compile Include="Crypto\BufferedCipherBase.cs" />
    <Compile Include="Crypto\CryptoException.cs" />
    <Compile Include="Crypto\DataLengthException.cs" />
    <Compile Include="Crypto\GeneralDigest.cs" />
+    <Compile Include="Crypto\HMac.cs" />
    <Compile Include="Crypto\IBlockCipher.cs" />
+    <Compile Include="Crypto\IBufferedCipher.cs" />
    <Compile Include="Crypto\ICipherParameters.cs" />
    <Compile Include="Crypto\IDigest.cs" />
+    <Compile Include="Crypto\IMac.cs" />
    <Compile Include="Crypto\KeyParameter.cs" />
+    <Compile Include="Crypto\PBKDF2.cs" />
    <Compile Include="Crypto\RijndaelEngine.cs" />
    <Compile Include="Crypto\Pack.cs" />
    <Compile Include="Crypto\Sha1Digest.cs" />
--- a/SharpCompress/SharpCompress.csproj
+++ b/SharpCompress/SharpCompress.csproj
@@ -152,8 +152,10 @@
    <Compile Include="Common\Zip\SeekableZipHeaderFactory.cs" />
    <Compile Include="Common\Zip\StreamingZipFilePart.cs" />
    <Compile Include="Common\Zip\StreamingZipHeaderFactory.cs" />
+    <Compile Include="Common\Zip\WinzipAesCryptoStream.cs">
+      <SubType>Code</SubType>
+    </Compile>
    <Compile Include="Common\Zip\WinzipAesEncryptionData.cs" />
-    <Compile Include="Common\Zip\WinzipAesCryptoStream.cs" />
    <Compile Include="Common\Zip\WinzipAesKeySize.cs" />
    <Compile Include="Common\Zip\ZipVolume.cs" />
    <Compile Include="Compressor\BZip2\BZip2Constants.cs" />