Mark for 0.15

Add zip64 support for ZipArchive extraction

.gitignore

@@ -13,3 +13,4 @@ project.lock.json
 test/TestArchives/Scratch
 .vs
 tools
+.vscode

FORMATS.md

@@ -10,12 +10,12 @@ Writer classes allow forward-only Writing
 | --- | --- | --- | --- | --- | --- |
 | Rar | Rar | Decompress (1) | RarArchive | RarReader | N/A |
 | Zip (2) | None, DEFLATE, BZip2, LZMA/LZMA2, PPMd | Both | ZipArchive | ZipReader | ZipWriter |
-| Tar | None, BZip2, GZip | Both | TarArchive | TarReader | TarWriter (3)  |
+| Tar | None, BZip2, GZip, LZip | Both | TarArchive | TarReader | TarWriter (3)  |
 | GZip (single file) | GZip | Both | GZipArchive | GZipReader | GZipWriter |
 | 7Zip (4) | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate | Decompress | SevenZipArchive | N/A | N/A |
 
  1. SOLID Rars are only supported in the RarReader API.
- 2. Zip format supports pkware and WinzipAES encryption.  However, encrypted LZMA is not supported.
+ 2. Zip format supports pkware and WinzipAES encryption.  However, encrypted LZMA is not supported.  Zip64 reading is supported with the Archive API
  3. The Tar format requires a file size in the header.  If no size is specified to the TarWriter and the stream is not seekable, then an exception will be thrown.
  4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API
 
@@ -30,3 +30,4 @@ For those who want to directly compress/decompress bits
 | LZMAStream | Both |
 | PPMdStream | Both |
 | ADCStream | Decompress |
+| LZipStream | Decompress |

README.md

@@ -25,12 +25,26 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 
 * RAR 5 support
 * 7Zip writing
-* Zip64
+* Zip64 (Need writing and extend Reading)
 * Multi-volume Zip support.
 * RAR5 support
 
 ## Version Log
 
+### Version 0.15.0
+
+* [Add zip64 support for ZipArchive extraction](https://github.com/adamhathcock/sharpcompress/pull/205)
+
+### 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)
+
 ### Version 0.13.1
 
 * [Fix null password on ReaderFactory. Fix null options on SevenZipArchive](https://github.com/adamhathcock/sharpcompress/pull/188)
@@ -113,8 +127,6 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 * Embedded some BouncyCastle crypto classes to allow RAR Decryption and Winzip AES Decryption in Portable and Windows Store DLLs
 * Built in Release (I think)
 
-Some Help/Discussion: https://sharpcompress.codeplex.com/discussions
-
 7Zip implementation based on: https://code.google.com/p/managed-lzma/
 
 LICENSE

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

USAGE.md

@@ -80,7 +80,7 @@ using (var archive = RarArchive.Open("Test.rar"))
 ### Use ReaderFactory to autodetect archive type and Open the entry stream
 
 ```C#
-using (Stream stream = File.OpenRead("Tar.tar.bz2")))
+using (Stream stream = File.OpenRead("Tar.tar.bz2"))
 using (var reader = ReaderFactory.Open(stream))
 {
     while (reader.MoveToNextEntry())
@@ -101,7 +101,7 @@ using (var reader = ReaderFactory.Open(stream))
 ### Use ReaderFactory to autodetect archive type and Open the entry stream
 
 ```C#
-using (Stream stream = File.OpenRead("Tar.tar.bz2")))
+using (Stream stream = File.OpenRead("Tar.tar.bz2"))
 using (var reader = ReaderFactory.Open(stream))
 {
     while (reader.MoveToNextEntry())
@@ -128,4 +128,4 @@ using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOption
 {
     writer.WriteAll("D:\\temp", "*", SearchOption.AllDirectories);
 }
-```
+```

appveyor.yml

@@ -1,4 +1,4 @@
-version: '0.13.{build}'
+version: '0.15.{build}'
 
 init:
 - git config --global core.autocrlf true

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/CompressionType.cs

@@ -11,6 +11,7 @@
         LZMA,
         BCJ,
         BCJ2,
+        LZip,
         Unknown
     }
 }

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/DirectoryEndHeader.cs

@@ -48,5 +48,15 @@ namespace SharpCompress.Common.Zip.Headers
         public byte[] Comment { get; private set; }
 
         public ushort TotalNumberOfEntries { get; private set; }
+
+        public bool IsZip64
+        {
+            get
+            {
+                return TotalNumberOfEntriesInDisk == ushort.MaxValue
+                       || DirectorySize == uint.MaxValue
+                       || DirectoryStartOffsetRelativeToDisk == uint.MaxValue;
+            }
+        }
     }
 }

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

@@ -0,0 +1,54 @@
+using System;
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal class Zip64DirectoryEndHeader : ZipHeader
+    {
+        public Zip64DirectoryEndHeader()
+            : base(ZipHeaderType.Zip64DirectoryEnd)
+        {
+        }
+
+        internal override void Read(BinaryReader reader)
+        {
+            SizeOfDirectoryEndRecord = (long)reader.ReadUInt64();
+            VersionMadeBy = reader.ReadUInt16();
+            VersionNeededToExtract = reader.ReadUInt16();
+            VolumeNumber = reader.ReadUInt32();
+            FirstVolumeWithDirectory = reader.ReadUInt32();
+            TotalNumberOfEntriesInDisk = (long)reader.ReadUInt64();
+            TotalNumberOfEntries = (long)reader.ReadUInt64();
+            DirectorySize = (long)reader.ReadUInt64();
+            DirectoryStartOffsetRelativeToDisk = (long)reader.ReadUInt64();
+            DataSector = reader.ReadBytes((int)(SizeOfDirectoryEndRecord - SizeOfFixedHeaderDataExceptSignatureAndSizeFields));
+        }
+
+        const int SizeOfFixedHeaderDataExceptSignatureAndSizeFields = 44;
+
+        internal override void Write(BinaryWriter writer)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public long SizeOfDirectoryEndRecord { get; private set; }
+
+        public ushort VersionMadeBy { get; private set; }
+
+        public ushort VersionNeededToExtract { get; private set; }
+
+        public uint VolumeNumber { get; private set; }
+
+        public uint FirstVolumeWithDirectory { get; private set; }
+
+        public long TotalNumberOfEntriesInDisk { get; private set; }
+
+        public long TotalNumberOfEntries { get; private set; }
+
+        public long DirectorySize { get; private set; }
+
+        public long DirectoryStartOffsetRelativeToDisk { get; private set; }
+
+        public byte[] DataSector { get; private set; }
+    }
+}

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

@@ -0,0 +1,30 @@
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal class Zip64DirectoryEndLocatorHeader : ZipHeader
+    {
+        public Zip64DirectoryEndLocatorHeader()
+            : base(ZipHeaderType.Zip64DirectoryEndLocator)
+        {
+        }
+
+        internal override void Read(BinaryReader reader)
+        {
+            FirstVolumeWithDirectory = reader.ReadUInt32();
+            RelativeOffsetOfTheEndOfDirectoryRecord = (long)reader.ReadUInt64();
+            TotalNumberOfVolumes = reader.ReadUInt32();
+        }
+
+        internal override void Write(BinaryWriter writer)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public uint FirstVolumeWithDirectory { get; private set; }
+
+        public long RelativeOffsetOfTheEndOfDirectoryRecord { get; private set; }
+
+        public uint TotalNumberOfVolumes { get; private set; }
+    }
+}

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

@@ -57,15 +57,31 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal ZipCompressionMethod CompressionMethod { get; set; }
 
-        internal uint CompressedSize { get; set; }
+        internal long CompressedSize { get; set; }
 
         internal long? DataStartPosition { get; set; }
 
-        internal uint UncompressedSize { get; set; }
+        internal long 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
@@ -96,5 +112,7 @@ namespace SharpCompress.Common.Zip.Headers
         }
 
         internal ZipFilePart Part { get; set; }
+
+        internal bool IsZip64 { get { return CompressedSize == uint.MaxValue; } }
     }
 }

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

@@ -6,6 +6,8 @@
         LocalEntry,
         DirectoryEntry,
         DirectoryEnd,
-        Split
+        Split,
+        Zip64DirectoryEnd,
+        Zip64DirectoryEndLocator
     }
 }

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -9,6 +9,7 @@ namespace SharpCompress.Common.Zip
     internal class SeekableZipHeaderFactory : ZipHeaderFactory
     {
         private const int MAX_ITERATIONS_FOR_DIRECTORY_HEADER = 4096;
+        private bool zip64;
 
         internal SeekableZipHeaderFactory(string password)
             : base(StreamingMode.Seekable, password)
@@ -16,11 +17,56 @@ namespace SharpCompress.Common.Zip
         }
 
         internal IEnumerable<DirectoryEntryHeader> ReadSeekableHeader(Stream stream)
+        {
+            var reader = new BinaryReader(stream);
+
+            SeekBackToHeader(stream, reader, DIRECTORY_END_HEADER_BYTES);
+            var entry = new DirectoryEndHeader();
+            entry.Read(reader);
+
+            if (entry.IsZip64)
+            {
+                zip64 = true;
+                SeekBackToHeader(stream, reader, ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR);
+                var zip64Locator = new Zip64DirectoryEndLocatorHeader();
+                zip64Locator.Read(reader);
+
+                stream.Seek(zip64Locator.RelativeOffsetOfTheEndOfDirectoryRecord, SeekOrigin.Begin);
+                uint zip64Signature = reader.ReadUInt32();
+                if(zip64Signature != ZIP64_END_OF_CENTRAL_DIRECTORY)
+                    throw new ArchiveException("Failed to locate the Zip64 Header");
+
+                var zip64Entry = new Zip64DirectoryEndHeader();
+                zip64Entry.Read(reader);
+                stream.Seek(zip64Entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
+            }
+            else
+            {
+                stream.Seek(entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
+            }
+
+            long position = stream.Position;
+            while (true)
+            {
+                stream.Position = position;
+                uint signature = reader.ReadUInt32();
+                var directoryEntryHeader = ReadHeader(signature, reader, zip64) as DirectoryEntryHeader;
+                position = stream.Position;
+                if (directoryEntryHeader == null)
+                {
+                    yield break;
+                }
+
+                //entry could be zero bytes so we need to know that.
+                directoryEntryHeader.HasData = directoryEntryHeader.CompressedSize != 0;
+                yield return directoryEntryHeader;
+            }
+        }
+
+        private static void SeekBackToHeader(Stream stream, BinaryReader reader, uint headerSignature)
         {
             long offset = 0;
             uint signature;
-            BinaryReader reader = new BinaryReader(stream);
-
             int iterationCount = 0;
             do
             {
@@ -34,33 +80,10 @@ namespace SharpCompress.Common.Zip
                 iterationCount++;
                 if (iterationCount > MAX_ITERATIONS_FOR_DIRECTORY_HEADER)
                 {
-                    throw new ArchiveException(
-                                               "Could not find Zip file Directory at the end of the file.  File may be corrupted.");
+                    throw new ArchiveException("Could not find Zip file Directory at the end of the file.  File may be corrupted.");
                 }
             }
-            while (signature != DIRECTORY_END_HEADER_BYTES);
-
-            var entry = new DirectoryEndHeader();
-            entry.Read(reader);
-            stream.Seek(entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
-
-            DirectoryEntryHeader directoryEntryHeader = null;
-            long position = stream.Position;
-            while (true)
-            {
-                stream.Position = position;
-                signature = reader.ReadUInt32();
-                directoryEntryHeader = ReadHeader(signature, reader) as DirectoryEntryHeader;
-                position = stream.Position;
-                if (directoryEntryHeader == null)
-                {
-                    yield break;
-                }
-
-                //entry could be zero bytes so we need to know that.
-                directoryEntryHeader.HasData = directoryEntryHeader.CompressedSize != 0;
-                yield return directoryEntryHeader;
-            }
+            while (signature != headerSignature);
         }
 
         internal LocalEntryHeader GetLocalHeader(Stream stream, DirectoryEntryHeader directoryEntryHeader)
@@ -68,7 +91,7 @@ namespace SharpCompress.Common.Zip
             stream.Seek(directoryEntryHeader.RelativeOffsetOfEntryHeader, SeekOrigin.Begin);
             BinaryReader reader = new BinaryReader(stream);
             uint signature = reader.ReadUInt32();
-            var localEntryHeader = ReadHeader(signature, reader) as LocalEntryHeader;
+            var localEntryHeader = ReadHeader(signature, reader, zip64) as LocalEntryHeader;
             if (localEntryHeader == null)
             {
                 throw new InvalidOperationException();

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -126,18 +126,16 @@ 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)
+
+            if ((Header.CompressedSize == 0
                 && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
+                || Header.IsZip64)
             {
                 plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close    
             }
@@ -145,18 +143,40 @@ namespace SharpCompress.Common.Zip
             {
                 plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close
             }
-            if (Header.PkwareTraditionalEncryptionData != null)
+
+            if (isFileEncrypted)
             {
-                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

@@ -17,8 +17,8 @@ namespace SharpCompress.Common.Zip
         internal const uint DIGITAL_SIGNATURE = 0x05054b50;
         internal const uint SPLIT_ARCHIVE_HEADER_BYTES = 0x30304b50;
 
-        private const uint ZIP64_END_OF_CENTRAL_DIRECTORY = 0x06064b50;
-        private const uint ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR = 0x07064b50;
+        internal const uint ZIP64_END_OF_CENTRAL_DIRECTORY = 0x06064b50;
+        internal const uint ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR = 0x07064b50;
 
         protected LocalEntryHeader lastEntryHeader;
         private readonly string password;
@@ -30,7 +30,7 @@ namespace SharpCompress.Common.Zip
             this.password = password;
         }
 
-        protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader)
+        protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader, bool zip64 = false)
         {
             switch (headerBytes)
             {
@@ -54,14 +54,12 @@ namespace SharpCompress.Common.Zip
                     if (FlagUtility.HasFlag(lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
                     {
                         lastEntryHeader.Crc = reader.ReadUInt32();
-                        lastEntryHeader.CompressedSize = reader.ReadUInt32();
-                        lastEntryHeader.UncompressedSize = reader.ReadUInt32();
+                        lastEntryHeader.CompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
+                        lastEntryHeader.UncompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
                     }
                     else
                     {
-                        reader.ReadUInt32();
-                        reader.ReadUInt32();
-                        reader.ReadUInt32();
+                        reader.ReadBytes(zip64 ? 20 : 12);
                     }
                     return null;
                 }
@@ -78,9 +76,14 @@ namespace SharpCompress.Common.Zip
                     return new SplitHeader();
                 }
                 case ZIP64_END_OF_CENTRAL_DIRECTORY:
+                {
+                    var entry = new Zip64DirectoryEndHeader();
+                    entry.Read(reader);
+                    return entry;
+                }
                 case ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR:
                 {
-                    var entry = new IgnoreHeader(ZipHeaderType.Ignore);
+                    var entry = new Zip64DirectoryEndLocatorHeader();
                     entry.Read(reader);
                     return entry;
                 }
@@ -111,46 +114,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 +168,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/Compressors/LZMA/LZipStream.cs

@@ -0,0 +1,153 @@
+using System;
+using System.IO;
+
+namespace SharpCompress.Compressors.LZMA
+{
+    // TODO:
+    // - Write as well as read
+    // - Multi-volume support
+    // - Use of the data size / member size values at the end of the stream
+
+    /// <summary>
+    /// Stream supporting the LZIP format, as documented at http://www.nongnu.org/lzip/manual/lzip_manual.html
+    /// </summary>
+    public class LZipStream : Stream
+    {
+        private readonly Stream stream;
+        private bool disposed;
+        private readonly bool leaveOpen;
+
+        public LZipStream(Stream stream, CompressionMode mode)
+            : this(stream, mode, false)
+        {
+        }
+
+        public LZipStream(Stream stream, CompressionMode mode, bool leaveOpen)
+        {
+            if (mode != CompressionMode.Decompress)
+            {
+                throw new NotImplementedException("Only LZip decompression is currently supported");
+            }
+            Mode = mode;
+            this.leaveOpen = leaveOpen;
+            int dictionarySize = ValidateAndReadSize(stream);
+            if (dictionarySize == 0)
+            {
+                throw new IOException("Not an LZip stream");
+            }
+            byte[] properties = GetProperties(dictionarySize);
+            this.stream = new LzmaStream(properties, stream);
+        }
+
+        #region Stream methods
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposed)
+            {
+                return;
+            }
+            disposed = true;
+            if (disposing && !leaveOpen)
+            {
+                stream.Dispose();
+            }
+        }
+
+        public CompressionMode Mode { get; }
+
+        public override bool CanRead => stream.CanRead;
+
+        public override bool CanSeek => false;
+
+        public override bool CanWrite => false;
+
+        public override void Flush()
+        {
+            stream.Flush();
+        }
+    
+        // TODO: Both Length and Position are sometimes feasible, but would require
+        // reading the output length when we initialize.
+        public override long Length { get { throw new NotImplementedException(); } }
+
+        public override long Position { get { throw new NotImplementedException(); } set { throw new NotImplementedException(); } }
+
+        public override int Read(byte[] buffer, int offset, int count) => stream.Read(buffer, offset, count);
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+
+        /// <summary>
+        /// Determines if the given stream is positioned at the start of a v1 LZip
+        /// file, as indicated by the ASCII characters "LZIP" and a version byte
+        /// of 1, followed by at least one byte.
+        /// </summary>
+        /// <param name="stream">The stream to read from. Must not be null.</param>
+        /// <returns><c>true</c> if the given stream is an LZip file, <c>false</c> otherwise.</returns>
+        public static bool IsLZipFile(Stream stream) => ValidateAndReadSize(stream) != 0;
+
+        /// <summary>
+        /// Reads the 6-byte header of the stream, and returns 0 if either the header
+        /// couldn't be read or it isn't a validate LZIP header, or the dictionary
+        /// size if it *is* a valid LZIP file.
+        /// </summary>
+        private static int ValidateAndReadSize(Stream stream)
+        {
+            if (stream == null)
+            {
+                throw new ArgumentNullException(nameof(stream));
+            }
+            // Read the header
+            byte[] header = new byte[6];
+            int n = stream.Read(header, 0, header.Length);
+
+            // TODO: Handle reading only part of the header?
+
+            if (n != 6)
+            {
+                return 0;
+            }
+
+            if (header[0] != 'L' || header[1] != 'Z' || header[2] != 'I' || header[3] != 'P' || header[4] != 1 /* version 1 */)
+            {
+                return 0;
+            }
+            int basePower = header[5] & 0x1F;
+            int subtractionNumerator = (header[5] & 0xE0) >> 5;
+            return (1 << basePower) - subtractionNumerator * (1 << (basePower - 4));
+        }
+
+        /// <summary>
+        /// Creates a byte array to communicate the parameters and dictionary size to LzmaStream.
+        /// </summary>
+        private static byte[] GetProperties(int dictionarySize) =>
+            new byte[]
+            {
+                // Parameters as per http://www.nongnu.org/lzip/manual/lzip_manual.html#Stream-format
+                // but encoded as a single byte in the format LzmaStream expects.
+                // literal_context_bits = 3
+                // literal_pos_state_bits = 0
+                // pos_state_bits = 2
+                93,
+                // Dictionary size as 4-byte little-endian value
+                (byte)(dictionarySize & 0xff),
+                (byte)((dictionarySize >> 8) & 0xff),
+                (byte)((dictionarySize >> 16) & 0xff),
+                (byte)((dictionarySize >> 24) & 0xff)
+            };
+    }
+}

src/SharpCompress/Readers/ReaderFactory.cs

@@ -13,6 +13,7 @@ using SharpCompress.Readers.GZip;
 using SharpCompress.Readers.Rar;
 using SharpCompress.Readers.Tar;
 using SharpCompress.Readers.Zip;
+using SharpCompress.Compressors.LZMA;
 
 namespace SharpCompress.Readers
 {
@@ -64,6 +65,18 @@ namespace SharpCompress.Readers
                 }
             }
 
+            rewindableStream.Rewind(false);
+            if (LZipStream.IsLZipFile(rewindableStream))
+            {
+                rewindableStream.Rewind(false);
+                LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, true);
+                if (TarArchive.IsTarFile(testStream))
+                {
+                    rewindableStream.Rewind(true);
+                    return new TarReader(rewindableStream, options, CompressionType.LZip);
+                }
+            }
+
             rewindableStream.Rewind(false);
             if (RarArchive.IsRarFile(rewindableStream, options))
             {

src/SharpCompress/Readers/Tar/TarReader.cs

@@ -9,6 +9,7 @@ using SharpCompress.Compressors;
 using SharpCompress.Compressors.BZip2;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.IO;
+using SharpCompress.Compressors.LZMA;
 
 namespace SharpCompress.Readers.Tar
 {
@@ -38,6 +39,10 @@ namespace SharpCompress.Readers.Tar
                 {
                     return new GZipStream(stream, CompressionMode.Decompress);
                 }
+                case CompressionType.LZip:
+                {
+                    return new LZipStream(stream, CompressionMode.Decompress);
+                }
                 case CompressionType.None:
                 {
                     return stream;
@@ -87,6 +92,19 @@ namespace SharpCompress.Readers.Tar
                 }
                 throw new InvalidFormatException("Not a tar file.");
             }
+
+            rewindableStream.Rewind(false);
+            if (LZipStream.IsLZipFile(rewindableStream))
+            {
+                rewindableStream.Rewind(false);
+                LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, false);
+                if (TarArchive.IsTarFile(testStream))
+                {
+                    rewindableStream.Rewind(true);
+                    return new TarReader(rewindableStream, options, CompressionType.LZip);
+                }
+                throw new InvalidFormatException("Not a tar file.");
+            }
             rewindableStream.Rewind(true);
             return new TarReader(rewindableStream, options, CompressionType.None);
         }

src/SharpCompress/project.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.13.1",
+    "version": "0.15.0",
     "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/Tar/TarReaderTests.cs

@@ -33,6 +33,12 @@ namespace SharpCompress.Test
             Read("Tar.tar.gz", CompressionType.GZip);
         }
 
+        [Fact]
+        public void Tar_LZip_Reader()
+        {
+            Read("Tar.tar.lz", CompressionType.LZip);
+        }
+
         [Fact]
         public void Tar_BZip2_Entry_Stream()
         {

test/SharpCompress.Test/Zip/ZipArchiveTests.cs

@@ -25,7 +25,6 @@ namespace SharpCompress.Test
             ArchiveStreamRead("Zip.zipx");
         }
 
-
         [Fact]
         public void Zip_BZip2_Streamed_ArchiveStreamRead()
         {
@@ -130,6 +129,18 @@ namespace SharpCompress.Test
             ArchiveFileRead("Zip.none.zip");
         }
 
+        [Fact]
+        public void Zip_Zip64_ArchiveStreamRead()
+        {
+            ArchiveStreamRead("Zip.zip64.zip");
+        }
+
+        [Fact]
+        public void Zip_Zip64_ArchiveFileRead()
+        {
+            ArchiveFileRead("Zip.zip64.zip");
+        }
+
         [Fact]
         public void Zip_Random_Write_Remove()
         {
@@ -374,6 +385,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": {