0.14.1

Gzip entry can't be read multiple times

README.md

@@ -31,6 +31,12 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 
 ## Version Log
 
+### Version 0.14.1
+
+* [.NET Assemblies aren't strong named](https://github.com/adamhathcock/sharpcompress/issues/158)
+* [Pkware encryption for Zip files didn't allow for multiple reads of an entry](https://github.com/adamhathcock/sharpcompress/issues/197)
+* [GZip Entry couldn't be read multiple times](https://github.com/adamhathcock/sharpcompress/issues/198)
+
 ### Version 0.14.0
 
 * [Support for LZip reading in for Tars](https://github.com/adamhathcock/sharpcompress/pull/191)

SharpCompress.sln

@@ -1,44 +1,44 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.24720.0
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F18F1765-4A02-42FD-9BEF-F0E2FCBD9D17}"
-	ProjectSection(SolutionItems) = preProject
-		global.json = global.json
-	EndProjectSection
-EndProject
-Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "SharpCompress", "src\SharpCompress\SharpCompress.xproj", "{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{3C5BE746-03E5-4895-9988-0B57F162F86C}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{0F0901FF-E8D9-426A-B5A2-17C7F47C1529}"
-EndProject
-Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "SharpCompress.Test", "test\SharpCompress.Test\SharpCompress.Test.xproj", "{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}"
-	ProjectSection(ProjectDependencies) = postProject
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {FD19DDD8-72B2-4024-8665-0D1F7A2AA998}
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Release|Any CPU.Build.0 = Release|Any CPU
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.24720.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F18F1765-4A02-42FD-9BEF-F0E2FCBD9D17}"
+	ProjectSection(SolutionItems) = preProject
+		global.json = global.json
+	EndProjectSection
+EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "SharpCompress", "src\SharpCompress\SharpCompress.xproj", "{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{3C5BE746-03E5-4895-9988-0B57F162F86C}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{0F0901FF-E8D9-426A-B5A2-17C7F47C1529}"
+EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "SharpCompress.Test", "test\SharpCompress.Test\SharpCompress.Test.xproj", "{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}"
+	ProjectSection(ProjectDependencies) = postProject
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {FD19DDD8-72B2-4024-8665-0D1F7A2AA998}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
+		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
+	EndGlobalSection
+EndGlobal

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -14,6 +14,12 @@ namespace SharpCompress.Archives.GZip
 
         public virtual Stream OpenEntryStream()
         {
+            //this is to reset the stream to be read multiple times
+            var part = Parts.Single() as GZipFilePart;
+            if (part.GetRawStream().Position != part.EntryStartPosition)
+            {
+                part.GetRawStream().Position = part.EntryStartPosition;
+            }
             return Parts.Single().GetCompressedStream();
         }
 

src/SharpCompress/AssemblyInfo.cs

@@ -4,6 +4,22 @@ using System.Runtime.CompilerServices;
 
 [assembly: AssemblyTitle("SharpCompress")]
 [assembly: AssemblyProduct("SharpCompress")]
-[assembly: InternalsVisibleTo("SharpCompress.Test")]
-[assembly: InternalsVisibleTo("SharpCompress.Test.Portable")]
-[assembly: CLSCompliant(true)]
+[assembly: InternalsVisibleTo("SharpCompress.Test" + SharpCompress.AssemblyInfo.PublicKeySuffix)]
+[assembly: InternalsVisibleTo("SharpCompress.Test.Portable"  + SharpCompress.AssemblyInfo.PublicKeySuffix)]
+[assembly: CLSCompliant(true)]
+
+namespace SharpCompress
+{
+    /// <summary>
+    /// Just a static class to house the public key, to avoid repetition.
+    /// </summary>
+    internal static class AssemblyInfo
+    {
+        internal const string PublicKeySuffix =
+            ",PublicKey=002400000480000094000000060200000024000052534131000400000100010059acfa17d26c44" +
+            "7a4d03f16eaa72c9187c04f16e6569dd168b080e39a6f5c9fd00f28c768cd8e9a089d5a0e1b34c" +
+            "cd971488e7afe030ce5ce8df2053cf12ec89f6d38065c434c09ee6af3ee284c5dc08f44774b679" +
+            "bf39298e57efe30d4b00aecf9e4f6f8448b2cb0146d8956dfcab606cc64a0ac38c60a7d78b0d65" +
+            "d3b98dc0";
+    }
+}

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -16,9 +16,12 @@ namespace SharpCompress.Common.GZip
         internal GZipFilePart(Stream stream)
         {
             ReadAndValidateGzipHeader(stream);
+            EntryStartPosition = stream.Position;
             this.stream = stream;
         }
 
+        internal long EntryStartPosition { get; }
+
         internal DateTime? DateModified { get; private set; }
 
         internal override string FilePartName { get { return name; } }

src/SharpCompress/Common/Zip/Headers/ZipFileEntry.cs

@@ -64,8 +64,24 @@ namespace SharpCompress.Common.Zip.Headers
         internal uint UncompressedSize { get; set; }
 
         internal List<ExtraData> Extra { get; set; }
+        
+        public string Password { get; set; }
+
+        internal PkwareTraditionalEncryptionData ComposeEncryptionData(Stream archiveStream)
+        {
+            if (archiveStream == null)
+            {
+                throw new ArgumentNullException(nameof(archiveStream));
+            }
+
+            var buffer = new byte[12];
+            archiveStream.Read(buffer, 0, 12);
+
+            PkwareTraditionalEncryptionData encryptionData = PkwareTraditionalEncryptionData.ForRead(Password, this, buffer);
+            
+            return encryptionData;
+        }
 
-        internal PkwareTraditionalEncryptionData PkwareTraditionalEncryptionData { get; set; }
 #if !NO_CRYPTO
         internal WinzipAesEncryptionData WinzipAesEncryptionData { get; set; }
 #endif

src/SharpCompress/Common/Zip/PkwareTraditionalEncryptionData.cs

@@ -9,11 +9,10 @@ namespace SharpCompress.Common.Zip
     {
         private static readonly CRC32 crc32 = new CRC32();
         private readonly UInt32[] _Keys = {0x12345678, 0x23456789, 0x34567890};
-        private readonly string password;
 
         private PkwareTraditionalEncryptionData(string password)
         {
-            this.password = password;
+            Initialize(password);
         }
 
         private byte MagicByte
@@ -29,7 +28,6 @@ namespace SharpCompress.Common.Zip
                                                               byte[] encryptionHeader)
         {
             var encryptor = new PkwareTraditionalEncryptionData(password);
-            encryptor.InitializeKeys();
             byte[] plainTextHeader = encryptor.Decrypt(encryptionHeader, encryptionHeader.Length);
             if (plainTextHeader[11] != (byte)((header.Crc >> 24) & 0xff))
             {
@@ -86,7 +84,7 @@ namespace SharpCompress.Common.Zip
             return cipherText;
         }
 
-        internal void InitializeKeys()
+        private void Initialize(string password)
         {
             byte[] p = StringToByteArray(password);
             for (int i = 0; i < password.Length; i++)

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -126,16 +126,13 @@ namespace SharpCompress.Common.Zip
 
         protected Stream GetCryptoStream(Stream plainStream)
         {
-            if ((Header.CompressedSize == 0)
-#if !NO_CRYPTO
- && ((Header.PkwareTraditionalEncryptionData != null)
-                    || (Header.WinzipAesEncryptionData != null)))
-#else
-                && (Header.PkwareTraditionalEncryptionData != null))
-#endif
+            bool isFileEncrypted = FlagUtility.HasFlag(Header.Flags, HeaderFlags.Encrypted);
+
+            if (Header.CompressedSize == 0 && isFileEncrypted)
             {
                 throw new NotSupportedException("Cannot encrypt file with unknown size at start.");
             }
+
             if ((Header.CompressedSize == 0)
                 && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
             {
@@ -145,19 +142,40 @@ namespace SharpCompress.Common.Zip
             {
                 plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close
             }
-            if (Header.PkwareTraditionalEncryptionData != null)
+
+            if (isFileEncrypted)
             {
-                Header.PkwareTraditionalEncryptionData.InitializeKeys();
-                return new PkwareTraditionalCryptoStream(plainStream, Header.PkwareTraditionalEncryptionData,
-                                                         CryptoMode.Decrypt);
-            }
+                switch (Header.CompressionMethod)
+                {
+                    case ZipCompressionMethod.None:
+                    case ZipCompressionMethod.Deflate:
+                    case ZipCompressionMethod.Deflate64:
+                    case ZipCompressionMethod.BZip2:
+                    case ZipCompressionMethod.LZMA:
+                    case ZipCompressionMethod.PPMd:
+                    {
+                        return new PkwareTraditionalCryptoStream(plainStream, Header.ComposeEncryptionData(plainStream), CryptoMode.Decrypt);
+                    }
+
+                    case ZipCompressionMethod.WinzipAes:
+                    {
 #if !NO_FILE
-            if (Header.WinzipAesEncryptionData != null)
-            {
-                //only read 10 less because the last ten are auth bytes
-                return new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData, Header.CompressedSize - 10);
-            }
+                        if (Header.WinzipAesEncryptionData != null)
+                        {
+                            return new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData, Header.CompressedSize - 10);
+                        }
 #endif
+                        return plainStream;
+                    }
+
+                    default:
+                    {
+                        throw new ArgumentOutOfRangeException();
+                    }
+
+                }
+            }
+
             return plainStream;
         }
     }

src/SharpCompress/Common/Zip/ZipHeaderFactory.cs

@@ -111,46 +111,43 @@ namespace SharpCompress.Common.Zip
         {
             if (FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.Encrypted))
             {
-                if (!entryHeader.IsDirectory &&
-                    entryHeader.CompressedSize == 0 &&
+                if (!entryHeader.IsDirectory && entryHeader.CompressedSize == 0 &&
                     FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
                 {
-                    throw new NotSupportedException(
-                                                    "SharpCompress cannot currently read non-seekable Zip Streams with encrypted data that has been written in a non-seekable manner.");
+                    throw new NotSupportedException("SharpCompress cannot currently read non-seekable Zip Streams with encrypted data that has been written in a non-seekable manner.");
                 }
+
                 if (password == null)
                 {
                     throw new CryptographicException("No password supplied for encrypted zip.");
                 }
-                if (entryHeader.CompressionMethod != ZipCompressionMethod.WinzipAes)
-                {
-                    byte[] buffer = new byte[12];
-                    stream.Read(buffer, 0, 12);
-                    entryHeader.PkwareTraditionalEncryptionData = PkwareTraditionalEncryptionData.ForRead(password,
-                                                                                                          entryHeader,
-                                                                                                          buffer);
-                    entryHeader.CompressedSize -= 12;
-                }
-                else
+
+                entryHeader.Password = password;
+
+                if (entryHeader.CompressionMethod == ZipCompressionMethod.WinzipAes)
                 {
 #if NO_CRYPTO
                     throw new NotSupportedException("Cannot decrypt Winzip AES with Silverlight or WP7.");
 #else
 
-                    var data = entryHeader.Extra.SingleOrDefault(x => x.Type == ExtraDataType.WinZipAes);
-                    WinzipAesKeySize keySize = (WinzipAesKeySize) data.DataBytes[4];
+                    ExtraData data = entryHeader.Extra.SingleOrDefault(x => x.Type == ExtraDataType.WinZipAes);
+                    if (data != null)
+                    {
+                        var keySize = (WinzipAesKeySize)data.DataBytes[4];
 
-                    byte[] salt = new byte[WinzipAesEncryptionData.KeyLengthInBytes(keySize)/2];
-                    byte[] passwordVerifyValue = new byte[2];
-                    stream.Read(salt, 0, salt.Length);
-                    stream.Read(passwordVerifyValue, 0, 2);
-                    entryHeader.WinzipAesEncryptionData = new WinzipAesEncryptionData(keySize, salt, passwordVerifyValue,
-                                                                                      password);
-                    entryHeader.CompressedSize -= (uint) (salt.Length + 2);
+                        var salt = new byte[WinzipAesEncryptionData.KeyLengthInBytes(keySize) / 2];
+                        var passwordVerifyValue = new byte[2];
+                        stream.Read(salt, 0, salt.Length);
+                        stream.Read(passwordVerifyValue, 0, 2);
+                        entryHeader.WinzipAesEncryptionData =
+                            new WinzipAesEncryptionData(keySize, salt, passwordVerifyValue, password);
 
+                        entryHeader.CompressedSize -= (uint)(salt.Length + 2);
+                    }
 #endif
                 }
             }
+
             if (entryHeader.IsDirectory)
             {
                 return;
@@ -168,13 +165,15 @@ namespace SharpCompress.Common.Zip
                 {
                     entryHeader.DataStartPosition = stream.Position;
                     stream.Position += entryHeader.CompressedSize;
-                }
                     break;
+                }
+
                 case StreamingMode.Streaming:
                 {
                     entryHeader.PackedStream = stream;
-                }
                     break;
+                }
+
                 default:
                 {
                     throw new InvalidFormatException("Invalid StreamingMode");

src/SharpCompress/project.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.14.0",
+    "version": "0.14.1",
     "title": "SharpCompress - Pure C# Decompression/Compression",
     "authors": [ "Adam Hathcock" ],
     "language": "en-US",
@@ -13,7 +13,8 @@
     },
     "buildOptions": {
         "warningsAsErrors": true,
-        "allowUnsafe": true
+        "allowUnsafe": true,
+        "keyFile": "../../SharpCompress.snk"
     },
     "frameworks": {
         "net35": {

test/SharpCompress.Test/GZip/GZipArchiveTests.cs

@@ -55,5 +55,47 @@ namespace SharpCompress.Test
                 archive.SaveTo(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz"));
             }
         }
+
+
+        [Fact]
+        public void GZip_Archive_Multiple_Reads()
+        {
+            ResetScratch();
+            var inputStream = new MemoryStream();
+            using (var fileStream = File.Open(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"), FileMode.Open))
+            {
+                fileStream.CopyTo(inputStream);
+                inputStream.Position = 0;
+            }
+            using (var archive = GZipArchive.Open(inputStream))
+            {
+                var archiveEntry = archive.Entries.First();
+
+                MemoryStream tarStream;
+                using (var entryStream = archiveEntry.OpenEntryStream())
+                {
+                    tarStream = new MemoryStream();
+                    entryStream.CopyTo(tarStream);
+                }
+                var size = tarStream.Length;
+                using (var entryStream = archiveEntry.OpenEntryStream())
+                {
+                    tarStream = new MemoryStream();
+                    entryStream.CopyTo(tarStream);
+                }
+                Assert.Equal(size, tarStream.Length);
+                using (var entryStream = archiveEntry.OpenEntryStream())
+                {
+                    var result = SharpCompress.Archives.Tar.TarArchive.IsTarFile(entryStream);
+                }
+                Assert.Equal(size, tarStream.Length);
+                using (var entryStream = archiveEntry.OpenEntryStream())
+                {
+                    tarStream = new MemoryStream();
+                    entryStream.CopyTo(tarStream);
+                }
+                Assert.Equal(size, tarStream.Length);
+            }
+        }
     }
 }

test/SharpCompress.Test/Zip/ZipArchiveTests.cs

@@ -183,32 +183,6 @@ namespace SharpCompress.Test
             Assert.Equal(new FileInfo(scratchPath1).Length, new FileInfo(scratchPath2).Length);
         }
 
-        [Fact]
-        public void Zip_Read_Entry_Twice()
-        {
-            string scratchPath = "C:\\Users\\adam\\Downloads\\Archive1.zip";
-
-            using (var archive = ArchiveFactory.Open(scratchPath, new ReaderOptions()
-                                                                  {
-                                                                      Password = "12345678"
-            }))
-            {
-                var entries = archive.Entries.Where(entry => !entry.IsDirectory);
-
-                foreach (var entry in entries)
-                {
-                    for (int i = 0; i < 2; i++)
-                    {
-                        using (var memoryStream = new MemoryStream())
-                        using (var entryStream = entry.OpenEntryStream())
-                        {
-                            entryStream.CopyTo(memoryStream);
-                        }
-                    }
-                }
-            }
-        }
-
         [Fact]
         public void Zip_Removal_Poly()
         {
@@ -400,6 +374,29 @@ namespace SharpCompress.Test
             Assert.Equal(count3, 3);
         }
 
+        [Fact]
+        public void Zip_Deflate_PKWear_Multipy_Entry_Access()
+        {
+            string zipFile = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.pkware.zip");
+
+            using (FileStream fileStream = File.Open(zipFile, FileMode.Open))
+            {
+                using (IArchive archive = ArchiveFactory.Open(fileStream, new ReaderOptions { Password = "12345678" }))
+                {
+                    var entries = archive.Entries.Where(entry => !entry.IsDirectory);
+                    foreach (IArchiveEntry entry in entries)
+                    {
+                        for (var i = 0; i < 100; i++)
+                        {
+                            using (var memoryStream = new MemoryStream())
+                            using (Stream entryStream = entry.OpenEntryStream())
+                                entryStream.CopyTo(memoryStream);
+                        }
+                    }
+                }
+            }
+
+        }
 
         class NonSeekableMemoryStream : MemoryStream
         {

test/SharpCompress.Test/project.json

@@ -1,4 +1,8 @@
 {
+    "buildOptions": {
+        "keyFile": "../../SharpCompress.snk"
+    },
+
     "testRunner": "xunit",
 
     "frameworks": {