Change more ReadBytes

.gitignore

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

FORMATS.md

@@ -1,28 +1,25 @@
 # Archive Formats
 
 ## Accessing Archives
-
 Archive classes allow random access to a seekable stream.
 Reader classes allow forward-only reading
 Writer classes allow forward-only Writing
 
 ## Supported Format Table
-
 | Archive Format | Compression Format(s) | Compress/Decompress | Archive API | Reader API | Writer API |
 | --- | --- | --- | --- | --- | --- |
 | Rar | Rar | Decompress (1) | RarArchive | RarReader | N/A |
 | Zip (2) | None, DEFLATE, BZip2, LZMA/LZMA2, PPMd | Both | ZipArchive | ZipReader | ZipWriter |
-| Tar | None, BZip2, GZip, LZip | Both | TarArchive | TarReader | TarWriter (3)  |
+| Tar | None, BZip2, GZip | 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.  Zip64 reading is supported.
+ 2. Zip format supports pkware and WinzipAES encryption.  However, encrypted LZMA is not supported.
  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
 
 ## Compressors
-
 For those who want to directly compress/decompress bits
 
 | Compressor | Compress/Decompress |
@@ -33,4 +30,3 @@ For those who want to directly compress/decompress bits
 | LZMAStream | Both |
 | PPMdStream | Both |
 | ADCStream | Decompress |
-| LZipStream | Decompress |

README.md

@@ -25,34 +25,12 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 
 * RAR 5 support
 * 7Zip writing
-* Zip64 (Need writing and extend Reading)
+* Zip64
 * Multi-volume Zip support.
 * RAR5 support
 
 ## Version Log
 
-### Version 0.15.2
-
-* [Fix invalid headers](https://github.com/adamhathcock/sharpcompress/pull/210) - fixes an issue creating large-ish zip archives that was introduced with zip64 reading.
-
-### Version 0.15.1
-
-* [Zip64 extending information and ZipReader](https://github.com/adamhathcock/sharpcompress/pull/206)
-
-### 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)
@@ -135,6 +113,8 @@ 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.15.{build}'
+version: '0.13.{build}'
 
 init:
 - git config --global core.autocrlf true

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.GZip;
 using SharpCompress.Writers;
@@ -103,26 +104,28 @@ namespace SharpCompress.Archives.GZip
         public static bool IsGZipFile(Stream stream)
         {
             // read the header on the first read
-            byte[] header = new byte[10];
-            int n = stream.Read(header, 0, header.Length);
-
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (n == 0)
+            using (var header = ByteArrayPool.RentScope(10))
             {
-                return false;
-            }
+                int n = stream.Read(header);
 
-            if (n != 10)
-            {
-                return false;
-            }
+                // workitem 8501: handle edge case (decompress empty stream)
+                if (n == 0)
+                {
+                    return false;
+                }
 
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-            {
-                return false;
-            }
+                if (n != 10)
+                {
+                    return false;
+                }
 
-            return true;
+                if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+                {
+                    return false;
+                }
+
+                return true;
+            }
         }
 
         /// <summary>

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -14,12 +14,6 @@ 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/Archives/SevenZip/SevenZipArchive.cs

@@ -141,8 +141,10 @@ namespace SharpCompress.Archives.SevenZip
         private static bool SignatureMatch(Stream stream)
         {
             BinaryReader reader = new BinaryReader(stream);
-            byte[] signatureBytes = reader.ReadBytes(6);
-            return signatureBytes.BinaryEquals(SIGNATURE);
+            using (var signatureBytes = reader.ReadScope(6))
+            {
+                return signatureBytes.BinaryEquals(SIGNATURE);
+            }
         }
 
         protected override IReader CreateReaderForSolidExtraction()

src/SharpCompress/AssemblyInfo.cs

@@ -4,22 +4,6 @@ using System.Runtime.CompilerServices;
 
 [assembly: AssemblyTitle("SharpCompress")]
 [assembly: AssemblyProduct("SharpCompress")]
-[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";
-    }
-}
+[assembly: InternalsVisibleTo("SharpCompress.Test")]
+[assembly: InternalsVisibleTo("SharpCompress.Test.Portable")]
+[assembly: CLSCompliant(true)]

src/SharpCompress/Common/CompressionType.cs

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

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -5,6 +5,7 @@ using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.Converters;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.GZip
 {
@@ -16,12 +17,9 @@ 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; } }
@@ -39,79 +37,85 @@ namespace SharpCompress.Common.GZip
         private void ReadAndValidateGzipHeader(Stream stream)
         {
             // read the header on the first read
-            byte[] header = new byte[10];
-            int n = stream.Read(header, 0, header.Length);
-
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (n == 0)
+            using (var header = ByteArrayPool.RentScope(10))
             {
-                return;
-            }
+                int n = stream.Read(header);
 
-            if (n != 10)
-            {
-                throw new ZlibException("Not a valid GZIP stream.");
-            }
-
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-            {
-                throw new ZlibException("Bad GZIP header.");
-            }
-
-            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
-            DateModified = TarHeader.Epoch.AddSeconds(timet);
-            if ((header[3] & 0x04) == 0x04)
-            {
-                // read and discard extra field
-                n = stream.Read(header, 0, 2); // 2-byte length field
-
-                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
-                byte[] extra = new byte[extraLength];
-                n = stream.Read(extra, 0, extra.Length);
-                if (n != extraLength)
+                // workitem 8501: handle edge case (decompress empty stream)
+                if (n == 0)
                 {
-                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+                    return;
+                }
+
+                if (n != 10)
+                {
+                    throw new ZlibException("Not a valid GZIP stream.");
+                }
+
+                if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+                {
+                    throw new ZlibException("Bad GZIP header.");
+                }
+
+                Int32 timet = DataConverter.LittleEndian.GetInt32(header.Array, 4);
+                DateModified = TarHeader.Epoch.AddSeconds(timet);
+                if ((header[3] & 0x04) == 0x04)
+                {
+                    // read and discard extra field
+                    n = stream.Read(header.Array, 0, 2); // 2-byte length field
+
+                    Int16 extraLength = (Int16)(header[0] + header[1] * 256);
+                    using (var extra = ByteArrayPool.RentScope(extraLength))
+                    {
+                        n = stream.Read(extra);
+                        if (n != extraLength)
+                        {
+                            throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+                        }
+                    }
+                }
+                if ((header[3] & 0x08) == 0x08)
+                {
+                    name = ReadZeroTerminatedString(stream);
+                }
+                if ((header[3] & 0x10) == 0x010)
+                {
+                    ReadZeroTerminatedString(stream);
+                }
+                if ((header[3] & 0x02) == 0x02)
+                {
+                    stream.ReadByte(); // CRC16, ignore
                 }
-            }
-            if ((header[3] & 0x08) == 0x08)
-            {
-                name = ReadZeroTerminatedString(stream);
-            }
-            if ((header[3] & 0x10) == 0x010)
-            {
-                ReadZeroTerminatedString(stream);
-            }
-            if ((header[3] & 0x02) == 0x02)
-            {
-                stream.ReadByte(); // CRC16, ignore
             }
         }
 
         private static string ReadZeroTerminatedString(Stream stream)
         {
-            byte[] buf1 = new byte[1];
-            var list = new List<byte>();
-            bool done = false;
-            do
+            using (var buf1 = ByteArrayPool.RentScope(1))
             {
-                // workitem 7740
-                int n = stream.Read(buf1, 0, 1);
-                if (n != 1)
+                var list = new List<byte>();
+                bool done = false;
+                do
                 {
-                    throw new ZlibException("Unexpected EOF reading GZIP header.");
-                }
-                if (buf1[0] == 0)
-                {
-                    done = true;
-                }
-                else
-                {
-                    list.Add(buf1[0]);
+                    // workitem 7740
+                    int n = stream.Read(buf1);
+                    if (n != 1)
+                    {
+                        throw new ZlibException("Unexpected EOF reading GZIP header.");
+                    }
+                    if (buf1[0] == 0)
+                    {
+                        done = true;
+                    }
+                    else
+                    {
+                        list.Add(buf1[0]);
+                    }
                 }
+                while (!done);
+                byte[] a = list.ToArray();
+                return ArchiveEncoding.Default.GetString(a, 0, a.Length);
             }
-            while (!done);
-            byte[] a = list.ToArray();
-            return ArchiveEncoding.Default.GetString(a, 0, a.Length);
         }
     }
 }

src/SharpCompress/Common/Rar/Headers/FileHeader.cs

@@ -47,81 +47,82 @@ namespace SharpCompress.Common.Rar.Headers
 
             nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
 
-            byte[] fileNameBytes = reader.ReadBytes(nameSize);
-
-            switch (HeaderType)
+            using (var fileNameBytes = reader.ReadScope(nameSize))
             {
-                case HeaderType.FileHeader:
+                switch (HeaderType)
                 {
-                    if (FileFlags.HasFlag(FileFlags.UNICODE))
+                    case HeaderType.FileHeader:
                     {
-                        int length = 0;
-                        while (length < fileNameBytes.Length
-                               && fileNameBytes[length] != 0)
+                        if (FileFlags.HasFlag(FileFlags.UNICODE))
                         {
-                            length++;
-                        }
-                        if (length != nameSize)
-                        {
-                            length++;
-                            FileName = FileNameDecoder.Decode(fileNameBytes, length);
+                            int length = 0;
+                            while (length < fileNameBytes.Count
+                                   && fileNameBytes[length] != 0)
+                            {
+                                length++;
+                            }
+                            if (length != nameSize)
+                            {
+                                length++;
+                                FileName = FileNameDecoder.Decode(fileNameBytes, length);
+                            }
+                            else
+                            {
+                                FileName = DecodeDefault(fileNameBytes);
+                            }
                         }
                         else
                         {
                             FileName = DecodeDefault(fileNameBytes);
                         }
+                        FileName = ConvertPath(FileName, HostOS);
                     }
-                    else
+                        break;
+                    case HeaderType.NewSubHeader:
                     {
-                        FileName = DecodeDefault(fileNameBytes);
-                    }
-                    FileName = ConvertPath(FileName, HostOS);
-                }
-                    break;
-                case HeaderType.NewSubHeader:
-                {
-                    int datasize = HeaderSize - NEWLHD_SIZE - nameSize;
-                    if (FileFlags.HasFlag(FileFlags.SALT))
-                    {
-                        datasize -= SALT_SIZE;
-                    }
-                    if (datasize > 0)
-                    {
-                        SubData = reader.ReadBytes(datasize);
-                    }
+                        int datasize = HeaderSize - NEWLHD_SIZE - nameSize;
+                        if (FileFlags.HasFlag(FileFlags.SALT))
+                        {
+                            datasize -= SALT_SIZE;
+                        }
+                        if (datasize > 0)
+                        {
+                            SubData = reader.ReadBytes(datasize);
+                        }
 
-                    if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
-                    {
-                        RecoverySectors = SubData[8] + (SubData[9] << 8)
-                                          + (SubData[10] << 16) + (SubData[11] << 24);
+                        if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
+                        {
+                            RecoverySectors = SubData[8] + (SubData[9] << 8)
+                                              + (SubData[10] << 16) + (SubData[11] << 24);
+                        }
                     }
+                        break;
                 }
-                    break;
-            }
 
-            if (FileFlags.HasFlag(FileFlags.SALT))
-            {
-                Salt = reader.ReadBytes(SALT_SIZE);
-            }
-            if (FileFlags.HasFlag(FileFlags.EXTTIME))
-            {
-                // verify that the end of the header hasn't been reached before reading the Extended Time.
-                //  some tools incorrectly omit Extended Time despite specifying FileFlags.EXTTIME, which most parsers tolerate.
-                if (ReadBytes + reader.CurrentReadByteCount <= HeaderSize - 2)
+                if (FileFlags.HasFlag(FileFlags.SALT))
                 {
-                    ushort extendedFlags = reader.ReadUInt16();
-                    FileLastModifiedTime = ProcessExtendedTime(extendedFlags, FileLastModifiedTime, reader, 0);
-                    FileCreatedTime = ProcessExtendedTime(extendedFlags, null, reader, 1);
-                    FileLastAccessedTime = ProcessExtendedTime(extendedFlags, null, reader, 2);
-                    FileArchivedTime = ProcessExtendedTime(extendedFlags, null, reader, 3);
+                    Salt = reader.ReadBytes(SALT_SIZE);
+                }
+                if (FileFlags.HasFlag(FileFlags.EXTTIME))
+                {
+                    // verify that the end of the header hasn't been reached before reading the Extended Time.
+                    //  some tools incorrectly omit Extended Time despite specifying FileFlags.EXTTIME, which most parsers tolerate.
+                    if (ReadBytes + reader.CurrentReadByteCount <= HeaderSize - 2)
+                    {
+                        ushort extendedFlags = reader.ReadUInt16();
+                        FileLastModifiedTime = ProcessExtendedTime(extendedFlags, FileLastModifiedTime, reader, 0);
+                        FileCreatedTime = ProcessExtendedTime(extendedFlags, null, reader, 1);
+                        FileLastAccessedTime = ProcessExtendedTime(extendedFlags, null, reader, 2);
+                        FileArchivedTime = ProcessExtendedTime(extendedFlags, null, reader, 3);
+                    }
                 }
             }
         }
 
         //only the full .net framework will do other code pages than unicode/utf8
-        private string DecodeDefault(byte[] bytes)
+        private string DecodeDefault(ByteArrayPoolScope bytes)
         {
-            return ArchiveEncoding.Default.GetString(bytes, 0, bytes.Length);
+            return ArchiveEncoding.Default.GetString(bytes.Array, 0, bytes.Count);
         }
 
         private long UInt32To64(uint x, uint y)

src/SharpCompress/Common/Rar/Headers/FileNameDecoder.cs

@@ -1,4 +1,5 @@
 using System.Text;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers
 {
@@ -7,12 +8,12 @@ namespace SharpCompress.Common.Rar.Headers
     /// </summary>
     internal static class FileNameDecoder
     {
-        internal static int GetChar(byte[] name, int pos)
+        internal static int GetChar(ByteArrayPoolScope name, int pos)
         {
             return name[pos] & 0xff;
         }
 
-        internal static string Decode(byte[] name, int encPos)
+        internal static string Decode(ByteArrayPoolScope name, int encPos)
         {
             int decPos = 0;
             int flags = 0;
@@ -22,7 +23,7 @@ namespace SharpCompress.Common.Rar.Headers
             int high = 0;
             int highByte = GetChar(name, encPos++);
             StringBuilder buf = new StringBuilder();
-            while (encPos < name.Length)
+            while (encPos < name.Count)
             {
                 if (flagBits == 0)
                 {
@@ -54,7 +55,7 @@ namespace SharpCompress.Common.Rar.Headers
                         if ((length & 0x80) != 0)
                         {
                             int correction = GetChar(name, encPos++);
-                            for (length = (length & 0x7f) + 2; length > 0 && decPos < name.Length; length--, decPos++)
+                            for (length = (length & 0x7f) + 2; length > 0 && decPos < name.Count; length--, decPos++)
                             {
                                 low = (GetChar(name, decPos) + correction) & 0xff;
                                 buf.Append((char)((highByte << 8) + low));
@@ -62,7 +63,7 @@ namespace SharpCompress.Common.Rar.Headers
                         }
                         else
                         {
-                            for (length += 2; length > 0 && decPos < name.Length; length--, decPos++)
+                            for (length += 2; length > 0 && decPos < name.Count; length--, decPos++)
                             {
                                 buf.Append((char)(GetChar(name, decPos)));
                             }

src/SharpCompress/Common/Rar/Headers/RarHeader.cs

@@ -62,7 +62,8 @@ namespace SharpCompress.Common.Rar.Headers
 
             if (headerSizeDiff > 0)
             {
-                reader.ReadBytes(headerSizeDiff);
+                using (reader.ReadScope(headerSizeDiff))
+                { }
             }
 
             return header;

src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs

@@ -52,35 +52,39 @@ namespace SharpCompress.Common.Rar.Headers
                     if (firstByte == 0x52)
                     {
                         MemoryStream buffer = new MemoryStream();
-                        byte[] nextThreeBytes = reader.ReadBytes(3);
-                        if ((nextThreeBytes[0] == 0x45)
-                            && (nextThreeBytes[1] == 0x7E)
-                            && (nextThreeBytes[2] == 0x5E))
+                        using (var nextThreeBytes = reader.ReadScope(3))
                         {
-                            //old format and isvalid
-                            buffer.WriteByte(0x52);
-                            buffer.Write(nextThreeBytes, 0, 3);
-                            rewindableStream.Rewind(buffer);
-                            break;
+                            if ((nextThreeBytes[0] == 0x45)
+                                && (nextThreeBytes[1] == 0x7E)
+                                && (nextThreeBytes[2] == 0x5E))
+                            {
+                                //old format and isvalid
+                                buffer.WriteByte(0x52);
+                                buffer.Write(nextThreeBytes.Array, 0, 3);
+                                rewindableStream.Rewind(buffer);
+                                break;
+                            }
+                            using (var secondThreeBytes = reader.ReadScope(3))
+                            {
+                                if ((nextThreeBytes[0] == 0x61)
+                                    && (nextThreeBytes[1] == 0x72)
+                                    && (nextThreeBytes[2] == 0x21)
+                                    && (secondThreeBytes[0] == 0x1A)
+                                    && (secondThreeBytes[1] == 0x07)
+                                    && (secondThreeBytes[2] == 0x00))
+                                {
+                                    //new format and isvalid
+                                    buffer.WriteByte(0x52);
+                                    buffer.Write(nextThreeBytes.Array, 0, 3);
+                                    buffer.Write(secondThreeBytes.Array, 0, 3);
+                                    rewindableStream.Rewind(buffer);
+                                    break;
+                                }
+                                buffer.Write(nextThreeBytes.Array, 0, 3);
+                                buffer.Write(secondThreeBytes.Array, 0, 3);
+                                rewindableStream.Rewind(buffer);
+                            }
                         }
-                        byte[] secondThreeBytes = reader.ReadBytes(3);
-                        if ((nextThreeBytes[0] == 0x61)
-                            && (nextThreeBytes[1] == 0x72)
-                            && (nextThreeBytes[2] == 0x21)
-                            && (secondThreeBytes[0] == 0x1A)
-                            && (secondThreeBytes[1] == 0x07)
-                            && (secondThreeBytes[2] == 0x00))
-                        {
-                            //new format and isvalid
-                            buffer.WriteByte(0x52);
-                            buffer.Write(nextThreeBytes, 0, 3);
-                            buffer.Write(secondThreeBytes, 0, 3);
-                            rewindableStream.Rewind(buffer);
-                            break;
-                        }
-                        buffer.Write(nextThreeBytes, 0, 3);
-                        buffer.Write(secondThreeBytes, 0, 3);
-                        rewindableStream.Rewind(buffer);
                     }
                     if (count > MAX_SFX_SIZE)
                     {

src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs

@@ -32,14 +32,21 @@ namespace SharpCompress.Common.Rar
 
         public override byte[] ReadBytes(int count)
         {
-            if (UseEncryption)
-            {
-                return ReadAndDecryptBytes(count);
-            }
-            return base.ReadBytes(count);
+            byte[] b = new byte[count];
+            Read(b, 0, count);
+            return b;
         }
 
-        private byte[] ReadAndDecryptBytes(int count)
+        public override int Read(byte[] buffer, int index, int count)
+        {
+            if (UseEncryption)
+            {
+                return ReadAndDecryptBytes(buffer, index, count);
+            }
+            return base.Read(buffer, index, count);
+        }
+
+        private int ReadAndDecryptBytes(byte[] buffer, int index, int count)
         {
             int queueSize = data.Count;
             int sizeToRead = count - queueSize;
@@ -49,23 +56,41 @@ namespace SharpCompress.Common.Rar
                 int alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
                 for (int i = 0; i < alignedSize / 16; i++)
                 {
-                    //long ax = System.currentTimeMillis();
-                    byte[] cipherText = base.ReadBytes(16);
-                    var readBytes = rijndael.ProcessBlock(cipherText);
-                    foreach (var readByte in readBytes)
-                        data.Enqueue(readByte);
-
+                    using (var cipherText = PrivateReadScope(16))
+                    {
+                        var readBytes = rijndael.ProcessBlock(cipherText);
+                        foreach (var readByte in readBytes)
+                        {
+                            data.Enqueue(readByte);
+                        }
+                    }
                 }
-
             }
-
-            var decryptedBytes = new byte[count];
-
-            for (int i = 0; i < count; i++)
+            
+            for (int i = index; i < count; i++)
             {
-                decryptedBytes[i] = data.Dequeue();
+                buffer[i] = data.Dequeue();
             }
-            return decryptedBytes;
+            return count;
+        }
+
+
+        private ByteArrayPoolScope PrivateReadScope(int count)
+        {
+            var scope = ByteArrayPool.RentScope(count);
+            int numRead = 0;
+            do
+            {
+                int n = base.Read(scope.Array, numRead, count);
+                if (n == 0)
+                {
+                    break;
+                }
+                numRead += n;
+                count -= n;
+            } while (count > 0);
+            scope.OverrideSize(numRead);
+            return scope;
         }
 
         public void ClearQueue()

src/SharpCompress/Common/Rar/RarCryptoWrapper.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar
 {
@@ -55,17 +56,21 @@ namespace SharpCompress.Common.Rar
                 for (int i = 0; i < alignedSize / 16; i++)
                 {
                     //long ax = System.currentTimeMillis();
-                    byte[] cipherText = new byte[RarRijndael.CRYPTO_BLOCK_SIZE];
-                    actualStream.Read(cipherText, 0, RarRijndael.CRYPTO_BLOCK_SIZE);
-
-                    var readBytes = rijndael.ProcessBlock(cipherText);
-                    foreach (var readByte in readBytes)
-                        data.Enqueue(readByte);
-
+                    using (var cipherText = ByteArrayPool.RentScope(RarRijndael.CRYPTO_BLOCK_SIZE))
+                    {
+                        actualStream.Read(cipherText.Array, 0, RarRijndael.CRYPTO_BLOCK_SIZE);
+                        var readBytes = rijndael.ProcessBlock(cipherText);
+                        foreach (var readByte in readBytes)
+                        {
+                            data.Enqueue(readByte);
+                        }
+                    }
                 }
 
                 for (int i = 0; i < count; i++)
+                {
                     buffer[offset + i] = data.Dequeue();
+                }
             }
             return count;
         }

src/SharpCompress/Common/Rar/RarRijndael.cs

@@ -6,6 +6,7 @@ using System.Security.Cryptography;
 using System.Text;
 using Org.BouncyCastle.Crypto.Engines;
 using Org.BouncyCastle.Crypto.Parameters;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar
 {
@@ -96,22 +97,24 @@ namespace SharpCompress.Common.Rar
             return rijndael;
         }
 
-        public byte[] ProcessBlock(byte[] cipherText)
+        public byte[] ProcessBlock(ByteArrayPoolScope cipherText)
         {
-            var plainText = new byte[CRYPTO_BLOCK_SIZE];
-            var decryptedBytes = new List<byte>();
-            rijndael.ProcessBlock(cipherText, 0, plainText, 0);
-
-            for (int j = 0; j < plainText.Length; j++)
+            using (var plainText = ByteArrayPool.RentScope(CRYPTO_BLOCK_SIZE))
             {
-                decryptedBytes.Add((byte) (plainText[j] ^ aesInitializationVector[j%16])); //32:114, 33:101
-            }
+                var decryptedBytes = new List<byte>();
+                rijndael.ProcessBlock(cipherText, plainText);
 
-            for (int j = 0; j < aesInitializationVector.Length; j++)
-            {
-                aesInitializationVector[j] = cipherText[j];
+                for (int j = 0; j < plainText.Count; j++)
+                {
+                    decryptedBytes.Add((byte)(plainText[j] ^ aesInitializationVector[j % 16])); //32:114, 33:101
+                }
+
+                for (int j = 0; j < aesInitializationVector.Length; j++)
+                {
+                    aesInitializationVector[j] = cipherText[j];
+                }
+                return decryptedBytes.ToArray();
             }
-            return decryptedBytes.ToArray();
         }
 
         public void Dispose()

src/SharpCompress/Common/Tar/Headers/TarHeader.cs

@@ -2,6 +2,7 @@
 using System.IO;
 using System.Text;
 using SharpCompress.Converters;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Tar.Headers
 {
@@ -87,63 +88,75 @@ namespace SharpCompress.Common.Tar.Headers
         internal bool Read(BinaryReader reader)
         {
             var buffer = ReadBlock(reader);
-            if (buffer.Length == 0)
+            try
             {
-                return false;
-            }
-
-            if (ReadEntryType(buffer) == EntryType.LongName)
-            {
-                Name = ReadLongName(reader, buffer);
-                buffer = ReadBlock(reader);
-            }
-            else
-            {
-                Name = ArchiveEncoding.Default.GetString(buffer, 0, 100).TrimNulls();
-            }
-
-            EntryType = ReadEntryType(buffer);
-            Size = ReadSize(buffer);
-
-            //Mode = ReadASCIIInt32Base8(buffer, 100, 7);
-            //UserId = ReadASCIIInt32Base8(buffer, 108, 7);
-            //GroupId = ReadASCIIInt32Base8(buffer, 116, 7);
-            long unixTimeStamp = ReadASCIIInt64Base8(buffer, 136, 11);
-            LastModifiedTime = Epoch.AddSeconds(unixTimeStamp).ToLocalTime();
-
-            Magic = ArchiveEncoding.Default.GetString(buffer, 257, 6).TrimNulls();
-
-            if (!string.IsNullOrEmpty(Magic)
-                && "ustar".Equals(Magic))
-            {
-                string namePrefix = ArchiveEncoding.Default.GetString(buffer, 345, 157);
-                namePrefix = namePrefix.TrimNulls();
-                if (!string.IsNullOrEmpty(namePrefix))
+                if (buffer.Count == 0)
                 {
-                    Name = namePrefix + "/" + Name;
+                    return false;
                 }
+
+                if (ReadEntryType(buffer.Array) == EntryType.LongName)
+                {
+                    Name = ReadLongName(reader, buffer.Array);
+                    buffer.Dispose();
+                    buffer = ReadBlock(reader);
+                }
+                else
+                {
+                    Name = ArchiveEncoding.Default.GetString(buffer.Array, 0, 100).TrimNulls();
+                }
+
+                EntryType = ReadEntryType(buffer.Array);
+                Size = ReadSize(buffer.Array);
+
+                //Mode = ReadASCIIInt32Base8(buffer, 100, 7);
+                //UserId = ReadASCIIInt32Base8(buffer, 108, 7);
+                //GroupId = ReadASCIIInt32Base8(buffer, 116, 7);
+                long unixTimeStamp = ReadASCIIInt64Base8(buffer.Array, 136, 11);
+                LastModifiedTime = Epoch.AddSeconds(unixTimeStamp).ToLocalTime();
+
+                Magic = ArchiveEncoding.Default.GetString(buffer.Array, 257, 6).TrimNulls();
+
+                if (!string.IsNullOrEmpty(Magic)
+                    && "ustar".Equals(Magic))
+                {
+                    string namePrefix = ArchiveEncoding.Default.GetString(buffer.Array, 345, 157);
+                    namePrefix = namePrefix.TrimNulls();
+                    if (!string.IsNullOrEmpty(namePrefix))
+                    {
+                        Name = namePrefix + "/" + Name;
+                    }
+                }
+                if (EntryType != EntryType.LongName
+                    && Name.Length == 0)
+                {
+                    return false;
+                }
+                return true;
             }
-            if (EntryType != EntryType.LongName
-                && Name.Length == 0)
+            finally
             {
-                return false;
+                buffer.Dispose();
             }
-            return true;
         }
 
         private string ReadLongName(BinaryReader reader, byte[] buffer)
         {
             var size = ReadSize(buffer);
             var nameLength = (int)size;
-            var nameBytes = reader.ReadBytes(nameLength);
-            var remainingBytesToRead = BlockSize - (nameLength % BlockSize);
-
-            // Read the rest of the block and discard the data
-            if (remainingBytesToRead < BlockSize)
+            using (var nameBytes = reader.ReadScope(nameLength))
             {
-                reader.ReadBytes(remainingBytesToRead);
+                var remainingBytesToRead = BlockSize - (nameLength % BlockSize);
+
+                // Read the rest of the block and discard the data
+                if (remainingBytesToRead < BlockSize)
+                {
+                    using (reader.ReadScope(remainingBytesToRead))
+                    {
+                    }
+                }
+                return ArchiveEncoding.Default.GetString(nameBytes.Array, 0, nameBytes.Count).TrimNulls();
             }
-            return ArchiveEncoding.Default.GetString(nameBytes, 0, nameBytes.Length).TrimNulls();
         }
 
         private static EntryType ReadEntryType(byte[] buffer)
@@ -160,11 +173,11 @@ namespace SharpCompress.Common.Tar.Headers
             return ReadASCIIInt64Base8(buffer, 124, 11);
         }
 
-        private static byte[] ReadBlock(BinaryReader reader)
+        private static ByteArrayPoolScope ReadBlock(BinaryReader reader)
         {
-            byte[] buffer = reader.ReadBytes(BlockSize);
+            var buffer = reader.ReadScope(BlockSize);
 
-            if (buffer.Length != 0 && buffer.Length < BlockSize)
+            if (buffer.Count != 0 && buffer.Count < BlockSize)
             {
                 throw new InvalidOperationException("Buffer is invalid size");
             }

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

@@ -48,15 +48,5 @@ 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/DirectoryEntryHeader.cs

@@ -1,6 +1,6 @@
-using System;
-using System.IO;
+using System.IO;
 using System.Linq;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -30,35 +30,22 @@ namespace SharpCompress.Common.Zip.Headers
             ExternalFileAttributes = reader.ReadUInt32();
             RelativeOffsetOfEntryHeader = reader.ReadUInt32();
 
-            byte[] name = reader.ReadBytes(nameLength);
-            Name = DecodeString(name);
-            byte[] extra = reader.ReadBytes(extraLength);
-            byte[] comment = reader.ReadBytes(commentLength);
-            Comment = DecodeString(comment);
-            LoadExtra(extra);
+            using (var name = reader.ReadScope(nameLength))
+            {
+                Name = DecodeString(name);
+            }
+            using (var extra = reader.ReadScope(extraLength))
+            using (var comment = reader.ReadScope(commentLength))
+            {
+                Comment = DecodeString(comment);
+                LoadExtra(extra);
+            }
 
             var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);
             if (unicodePathExtra != null)
             {
                 Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
             }
-
-            var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
-            if (zip64ExtraData != null)
-            {
-                if (CompressedSize == uint.MaxValue)
-                {
-                    CompressedSize = zip64ExtraData.CompressedSize;
-                }
-                if (UncompressedSize == uint.MaxValue)
-                {
-                    UncompressedSize = zip64ExtraData.UncompressedSize;
-                }
-                if (RelativeOffsetOfEntryHeader == uint.MaxValue)
-                {
-                    RelativeOffsetOfEntryHeader = zip64ExtraData.RelativeOffsetOfEntryHeader;
-                }
-            }
         }
 
         internal override void Write(BinaryWriter writer)
@@ -70,8 +57,8 @@ namespace SharpCompress.Common.Zip.Headers
             writer.Write(LastModifiedTime);
             writer.Write(LastModifiedDate);
             writer.Write(Crc);
-            writer.Write((uint)CompressedSize);
-            writer.Write((uint)UncompressedSize);
+            writer.Write(CompressedSize);
+            writer.Write(UncompressedSize);
 
             byte[] nameBytes = EncodeString(Name);
             writer.Write((ushort)nameBytes.Length);
@@ -95,7 +82,7 @@ namespace SharpCompress.Common.Zip.Headers
 
         public ushort VersionNeededToExtract { get; set; }
 
-        public long RelativeOffsetOfEntryHeader { get; set; }
+        public uint RelativeOffsetOfEntryHeader { get; set; }
 
         public uint ExternalFileAttributes { get; set; }
 

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

@@ -1,5 +1,6 @@
 using System.IO;
 using System.Linq;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -22,29 +23,18 @@ namespace SharpCompress.Common.Zip.Headers
             UncompressedSize = reader.ReadUInt32();
             ushort nameLength = reader.ReadUInt16();
             ushort extraLength = reader.ReadUInt16();
-            byte[] name = reader.ReadBytes(nameLength);
-            byte[] extra = reader.ReadBytes(extraLength);
-            Name = DecodeString(name);
-            LoadExtra(extra);
+            using (var name = reader.ReadScope(nameLength))
+            using (var extra = reader.ReadScope(extraLength))
+            {
+                Name = DecodeString(name);
+                LoadExtra(extra);
+            }
 
             var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);
             if (unicodePathExtra != null)
             {
                 Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
             }
-
-            var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
-            if (zip64ExtraData != null)
-            {
-                if (CompressedSize == uint.MaxValue)
-                {
-                    CompressedSize = zip64ExtraData.CompressedSize;
-                }
-                if (UncompressedSize == uint.MaxValue)
-                {
-                    UncompressedSize = zip64ExtraData.UncompressedSize;
-                }
-            }
         }
 
         internal override void Write(BinaryWriter writer)
@@ -55,8 +45,8 @@ namespace SharpCompress.Common.Zip.Headers
             writer.Write(LastModifiedTime);
             writer.Write(LastModifiedDate);
             writer.Write(Crc);
-            writer.Write((uint)CompressedSize);
-            writer.Write((uint)UncompressedSize);
+            writer.Write(CompressedSize);
+            writer.Write(UncompressedSize);
 
             byte[] nameBytes = EncodeString(Name);
 

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

@@ -1,6 +1,5 @@
 using System;
 using System.Text;
-using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -12,8 +11,7 @@ namespace SharpCompress.Common.Zip.Headers
 
         // Third Party Mappings
         // -Info-ZIP Unicode Path Extra Field
-        UnicodePathExtraField = 0x7075,
-        Zip64ExtendedInformationExtraField = 0x0001
+        UnicodePathExtraField = 0x7075
     }
 
     internal class ExtraData
@@ -49,73 +47,6 @@ namespace SharpCompress.Common.Zip.Headers
         }
     }
 
-    internal class Zip64ExtendedInformationExtraField : ExtraData
-    {
-
-        public Zip64ExtendedInformationExtraField(ExtraDataType type, ushort length, byte[] dataBytes)
-        {
-            Type = type;
-            Length = length;
-            DataBytes = dataBytes;
-            Process();
-        }
-
-        //From the spec values are only in the extradata if the standard
-        //value is set to 0xFFFF, but if one of the sizes are present, both are.
-        //Hence if length == 4 volume only
-        //      if length == 8 offset only
-        //      if length == 12 offset + volume
-        //      if length == 16 sizes only
-        //      if length == 20 sizes + volume
-        //      if length == 24 sizes + offset
-        //      if length == 28 everything.
-        //It is unclear how many of these are used in the wild.
-
-        private void Process()
-        {
-            switch (DataBytes.Length)
-            {
-                case 4:
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 0);
-                    return;
-                case 8:
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    return;
-                case 12:
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 8);
-                    return;
-                case 16:
-                     UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                     CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
-                    return;
-                case 20:
-                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 16);
-                    return;
-                case 24:
-                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 16);
-                    return;
-                case 28:
-                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 16);
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 24);
-                    return;
-                default:
-                throw new ArchiveException("Unexpected size of of Zip64 extended information extra field");
-            }
-        }
-
-        public long UncompressedSize { get; private set; }
-        public long CompressedSize { get; private set; }
-        public long RelativeOffsetOfEntryHeader { get; private set; }
-        public uint VolumeNumber { get; private set; }
-    }
-
     internal static class LocalEntryHeaderExtraFactory
     {
         internal static ExtraData Create(ExtraDataType type, ushort length, byte[] extraData)
@@ -129,13 +60,6 @@ namespace SharpCompress.Common.Zip.Headers
                                Length = length,
                                DataBytes = extraData
                            };
-                case ExtraDataType.Zip64ExtendedInformationExtraField:
-                    return new Zip64ExtendedInformationExtraField
-                            (
-                                type, 
-                                length,
-                                extraData
-                           );
                 default:
                     return new ExtraData
                            {

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

@@ -1,54 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using SharpCompress.Converters;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -30,14 +31,14 @@ namespace SharpCompress.Common.Zip.Headers
             }
         }
 
-        protected string DecodeString(byte[] str)
+        protected string DecodeString(ByteArrayPoolScope str)
         {
             if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8))
             {
-                return Encoding.UTF8.GetString(str, 0, str.Length);
+                return Encoding.UTF8.GetString(str.Array, 0, str.Count);
             }
 
-            return ArchiveEncoding.Default.GetString(str, 0, str.Length);
+            return ArchiveEncoding.Default.GetString(str.Array, 0, str.Count);
         }
 
         protected byte[] EncodeString(string str)
@@ -57,31 +58,15 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal ZipCompressionMethod CompressionMethod { get; set; }
 
-        internal long CompressedSize { get; set; }
+        internal uint CompressedSize { get; set; }
 
         internal long? DataStartPosition { get; set; }
 
-        internal long UncompressedSize { get; set; }
+        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
@@ -92,27 +77,27 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal uint Crc { get; set; }
 
-        protected void LoadExtra(byte[] extra)
+        protected void LoadExtra(ByteArrayPoolScope extra)
         {
-            for (int i = 0; i < extra.Length - 4;)
+            for (int i = 0; i < extra.Count - 4;)
             {
-                ExtraDataType type = (ExtraDataType)DataConverter.LittleEndian.GetUInt16(extra, i);
+                ExtraDataType type = (ExtraDataType)DataConverter.LittleEndian.GetUInt16(extra.Array, i);
                 if (!Enum.IsDefined(typeof(ExtraDataType), type))
                 {
                     type = ExtraDataType.NotImplementedExtraData;
                 }
 
-                ushort length = DataConverter.LittleEndian.GetUInt16(extra, i + 2);
-                byte[] data = new byte[length];
-                Buffer.BlockCopy(extra, i + 4, data, 0, length);
-                Extra.Add(LocalEntryHeaderExtraFactory.Create(type, length, data));
+                ushort length = DataConverter.LittleEndian.GetUInt16(extra.Array, i + 2);
+                using (var data = ByteArrayPool.RentScope(length))
+                {
+                    Buffer.BlockCopy(extra.Array, i + 4, data.Array, 0, length);
+                    Extra.Add(LocalEntryHeaderExtraFactory.Create(type, length, data.Array));
+                }
 
                 i += length + 4;
             }
         }
 
         internal ZipFilePart Part { get; set; }
-
-        internal bool IsZip64 { get { return CompressedSize == uint.MaxValue; } }
     }
 }

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

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

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -9,7 +9,6 @@ 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)
@@ -17,56 +16,11 @@ 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
             {
@@ -80,10 +34,33 @@ 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 != headerSignature);
+            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;
+            }
         }
 
         internal LocalEntryHeader GetLocalHeader(Stream stream, DirectoryEntryHeader directoryEntryHeader)
@@ -91,7 +68,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, zip64) as LocalEntryHeader;
+            var localEntryHeader = ReadHeader(signature, reader) as LocalEntryHeader;
             if (localEntryHeader == null)
             {
                 throw new InvalidOperationException();

src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs

@@ -28,7 +28,7 @@ namespace SharpCompress.Common.Zip
                 ZipHeader header = null;
                 BinaryReader reader = new BinaryReader(rewindableStream);
                 if (lastEntryHeader != null &&
-                    (FlagUtility.HasFlag(lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor) || lastEntryHeader.IsZip64))
+                    FlagUtility.HasFlag(lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
                 {
                     reader = (lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref rewindableStream);
                     long? pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -51,7 +51,7 @@ namespace SharpCompress.Common.Zip
 
         protected abstract Stream CreateBaseStream();
 
-        protected bool LeaveStreamOpen { get { return FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor) || Header.IsZip64; } }
+        protected bool LeaveStreamOpen { get { return FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor); } }
 
         protected Stream CreateDecompressionStream(Stream stream)
         {
@@ -126,16 +126,18 @@ namespace SharpCompress.Common.Zip
 
         protected Stream GetCryptoStream(Stream plainStream)
         {
-            bool isFileEncrypted = FlagUtility.HasFlag(Header.Flags, HeaderFlags.Encrypted);
-
-            if (Header.CompressedSize == 0 && isFileEncrypted)
+            if ((Header.CompressedSize == 0)
+#if !NO_CRYPTO
+ && ((Header.PkwareTraditionalEncryptionData != null)
+                    || (Header.WinzipAesEncryptionData != null)))
+#else
+                && (Header.PkwareTraditionalEncryptionData != null))
+#endif
             {
                 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    
             }
@@ -143,40 +145,18 @@ namespace SharpCompress.Common.Zip
             {
                 plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close
             }
-
-            if (isFileEncrypted)
+            if (Header.PkwareTraditionalEncryptionData != null)
             {
-                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)
-                        {
-                            return new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData, Header.CompressedSize - 10);
-                        }
-#endif
-                        return plainStream;
-                    }
-
-                    default:
-                    {
-                        throw new ArgumentOutOfRangeException();
-                    }
-
-                }
+                return new PkwareTraditionalCryptoStream(plainStream, Header.PkwareTraditionalEncryptionData,
+                                                         CryptoMode.Decrypt);
             }
-
+#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);
+            }
+#endif
             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;
 
-        internal const uint ZIP64_END_OF_CENTRAL_DIRECTORY = 0x06064b50;
-        internal const uint ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR = 0x07064b50;
+        private const uint ZIP64_END_OF_CENTRAL_DIRECTORY = 0x06064b50;
+        private 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, bool zip64 = false)
+        protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader)
         {
             switch (headerBytes)
             {
@@ -54,12 +54,14 @@ namespace SharpCompress.Common.Zip
                     if (FlagUtility.HasFlag(lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
                     {
                         lastEntryHeader.Crc = reader.ReadUInt32();
-                        lastEntryHeader.CompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
-                        lastEntryHeader.UncompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
+                        lastEntryHeader.CompressedSize = reader.ReadUInt32();
+                        lastEntryHeader.UncompressedSize = reader.ReadUInt32();
                     }
                     else
                     {
-                        reader.ReadBytes(zip64 ? 20 : 12);
+                        reader.ReadUInt32();
+                        reader.ReadUInt32();
+                        reader.ReadUInt32();
                     }
                     return null;
                 }
@@ -76,14 +78,9 @@ 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 Zip64DirectoryEndLocatorHeader();
+                    var entry = new IgnoreHeader(ZipHeaderType.Ignore);
                     entry.Read(reader);
                     return entry;
                 }
@@ -114,43 +111,46 @@ 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.");
                 }
-
-                entryHeader.Password = password;
-
-                if (entryHeader.CompressionMethod == ZipCompressionMethod.WinzipAes)
+                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
                 {
 #if NO_CRYPTO
                     throw new NotSupportedException("Cannot decrypt Winzip AES with Silverlight or WP7.");
 #else
 
-                    ExtraData data = entryHeader.Extra.SingleOrDefault(x => x.Type == ExtraDataType.WinZipAes);
-                    if (data != null)
-                    {
-                        var keySize = (WinzipAesKeySize)data.DataBytes[4];
+                    var data = entryHeader.Extra.SingleOrDefault(x => x.Type == ExtraDataType.WinZipAes);
+                    WinzipAesKeySize keySize = (WinzipAesKeySize) data.DataBytes[4];
 
-                        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);
+                    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);
 
-                        entryHeader.CompressedSize -= (uint)(salt.Length + 2);
-                    }
 #endif
                 }
             }
-
             if (entryHeader.IsDirectory)
             {
                 return;
@@ -168,15 +168,13 @@ namespace SharpCompress.Common.Zip
                 {
                     entryHeader.DataStartPosition = stream.Position;
                     stream.Position += entryHeader.CompressedSize;
-                    break;
                 }
-
+                    break;
                 case StreamingMode.Streaming:
                 {
                     entryHeader.PackedStream = stream;
-                    break;
                 }
-
+                    break;
                 default:
                 {
                     throw new InvalidFormatException("Invalid StreamingMode");

src/SharpCompress/Compressors/BZip2/BZip2Stream.cs

@@ -1,4 +1,5 @@
 using System.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.BZip2
 {
@@ -91,12 +92,14 @@ namespace SharpCompress.Compressors.BZip2
         public static bool IsBZip2(Stream stream)
         {
             BinaryReader br = new BinaryReader(stream);
-            byte[] chars = br.ReadBytes(2);
-            if (chars.Length < 2 || chars[0] != 'B' || chars[1] != 'Z')
+            using (var chars = br.ReadScope(2))
             {
-                return false;
+                if (chars.Count < 2 || chars[0] != 'B' || chars[1] != 'Z')
+                {
+                    return false;
+                }
+                return true;
             }
-            return true;
         }
     }
 }

src/SharpCompress/Compressors/Deflate/GZipStream.cs

@@ -30,6 +30,7 @@ using System;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.Converters;
+using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate
 {
@@ -413,67 +414,74 @@ namespace SharpCompress.Compressors.Deflate
             int fnLength = (FileName == null) ? 0 : filenameBytes.Length + 1;
 
             int bufferLength = 10 + cbLength + fnLength;
-            var header = new byte[bufferLength];
-            int i = 0;
-
-            // ID
-            header[i++] = 0x1F;
-            header[i++] = 0x8B;
-
-            // compression method
-            header[i++] = 8;
-            byte flag = 0;
-            if (Comment != null)
+            var header = ByteArrayPool.RentWritable(bufferLength);
+            try
             {
-                flag ^= 0x10;
+                int i = 0;
+
+                // ID
+                header[i++] = 0x1F;
+                header[i++] = 0x8B;
+
+                // compression method
+                header[i++] = 8;
+                byte flag = 0;
+                if (Comment != null)
+                {
+                    flag ^= 0x10;
+                }
+                if (FileName != null)
+                {
+                    flag ^= 0x8;
+                }
+
+                // flag
+                header[i++] = flag;
+
+                // mtime
+                if (!LastModified.HasValue)
+                {
+                    LastModified = DateTime.Now;
+                }
+                TimeSpan delta = LastModified.Value - UnixEpoch;
+                var timet = (Int32)delta.TotalSeconds;
+                DataConverter.LittleEndian.PutBytes(header, i, timet);
+                i += 4;
+
+                // xflg
+                header[i++] = 0; // this field is totally useless
+
+                // OS
+                header[i++] = 0xFF; // 0xFF == unspecified
+
+                // extra field length - only if FEXTRA is set, which it is not.
+                //header[i++]= 0;
+                //header[i++]= 0;
+
+                // filename
+                if (fnLength != 0)
+                {
+                    Array.Copy(filenameBytes, 0, header, i, fnLength - 1);
+                    i += fnLength - 1;
+                    header[i++] = 0; // terminate
+                }
+
+                // comment
+                if (cbLength != 0)
+                {
+                    Array.Copy(commentBytes, 0, header, i, cbLength - 1);
+                    i += cbLength - 1;
+                    header[i++] = 0; // terminate
+                }
+
+                BaseStream._stream.Write(header, 0, bufferLength);
+
+                return bufferLength; // bytes written
             }
-            if (FileName != null)
+            finally
             {
-                flag ^= 0x8;
+                ByteArrayPool.Return(header);
             }
-
-            // flag
-            header[i++] = flag;
-
-            // mtime
-            if (!LastModified.HasValue)
-            {
-                LastModified = DateTime.Now;
-            }
-            TimeSpan delta = LastModified.Value - UnixEpoch;
-            var timet = (Int32)delta.TotalSeconds;
-            DataConverter.LittleEndian.PutBytes(header, i, timet);
-            i += 4;
-
-            // xflg
-            header[i++] = 0; // this field is totally useless
-
-            // OS
-            header[i++] = 0xFF; // 0xFF == unspecified
-
-            // extra field length - only if FEXTRA is set, which it is not.
-            //header[i++]= 0;
-            //header[i++]= 0;
-
-            // filename
-            if (fnLength != 0)
-            {
-                Array.Copy(filenameBytes, 0, header, i, fnLength - 1);
-                i += fnLength - 1;
-                header[i++] = 0; // terminate
-            }
-
-            // comment
-            if (cbLength != 0)
-            {
-                Array.Copy(commentBytes, 0, header, i, cbLength - 1);
-                i += cbLength - 1;
-                header[i++] = 0; // terminate
-            }
-
-            BaseStream._stream.Write(header, 0, header.Length);
-
-            return header.Length; // bytes written
         }
     }
 }

src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs

@@ -30,6 +30,7 @@ using System.IO;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Converters;
+using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate
 {
@@ -267,46 +268,48 @@ namespace SharpCompress.Compressors.Deflate
                         }
 
                         // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-                        byte[] trailer = new byte[8];
-
-                        // workitem 8679
-                        if (_z.AvailableBytesIn != 8)
+                        using (var trailer = ByteArrayPool.RentScope(8))
                         {
-                            // Make sure we have read to the end of the stream
-                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, _z.AvailableBytesIn);
-                            int bytesNeeded = 8 - _z.AvailableBytesIn;
-                            int bytesRead = _stream.Read(trailer,
-                                                         _z.AvailableBytesIn,
-                                                         bytesNeeded);
-                            if (bytesNeeded != bytesRead)
+
+                            // workitem 8679
+                            if (_z.AvailableBytesIn != 8)
                             {
-                                throw new ZlibException(String.Format(
-                                                                      "Protocol error. AvailableBytesIn={0}, expected 8",
-                                                                      _z.AvailableBytesIn + bytesRead));
+                                // Make sure we have read to the end of the stream
+                                Array.Copy(_z.InputBuffer, _z.NextIn, trailer.Array, 0, _z.AvailableBytesIn);
+                                int bytesNeeded = 8 - _z.AvailableBytesIn;
+                                int bytesRead = _stream.Read(trailer.Array,
+                                                             _z.AvailableBytesIn,
+                                                             bytesNeeded);
+                                if (bytesNeeded != bytesRead)
+                                {
+                                    throw new ZlibException(String.Format(
+                                                                          "Protocol error. AvailableBytesIn={0}, expected 8",
+                                                                          _z.AvailableBytesIn + bytesRead));
+                                }
+                            }
+                            else
+                            {
+                                Array.Copy(_z.InputBuffer, _z.NextIn, trailer.Array, 0, trailer.Count);
                             }
-                        }
-                        else
-                        {
-                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
-                        }
 
-                        Int32 crc32_expected = DataConverter.LittleEndian.GetInt32(trailer, 0);
-                        Int32 crc32_actual = crc.Crc32Result;
-                        Int32 isize_expected = DataConverter.LittleEndian.GetInt32(trailer, 4);
-                        Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);
+                            Int32 crc32_expected = DataConverter.LittleEndian.GetInt32(trailer.Array, 0);
+                            Int32 crc32_actual = crc.Crc32Result;
+                            Int32 isize_expected = DataConverter.LittleEndian.GetInt32(trailer.Array, 4);
+                            Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);
 
-                        if (crc32_actual != crc32_expected)
-                        {
-                            throw new ZlibException(
-                                                    String.Format("Bad CRC32 in GZIP stream. (actual({0:X8})!=expected({1:X8}))",
-                                                                  crc32_actual, crc32_expected));
-                        }
+                            if (crc32_actual != crc32_expected)
+                            {
+                                throw new ZlibException(
+                                                        String.Format("Bad CRC32 in GZIP stream. (actual({0:X8})!=expected({1:X8}))",
+                                                                      crc32_actual, crc32_expected));
+                            }
 
-                        if (isize_actual != isize_expected)
-                        {
-                            throw new ZlibException(
-                                                    String.Format("Bad size in GZIP stream. (actual({0})!=expected({1}))", isize_actual,
-                                                                  isize_expected));
+                            if (isize_actual != isize_expected)
+                            {
+                                throw new ZlibException(
+                                                        String.Format("Bad size in GZIP stream. (actual({0})!=expected({1}))", isize_actual,
+                                                                      isize_expected));
+                            }
                         }
                     }
                     else
@@ -427,57 +430,61 @@ namespace SharpCompress.Compressors.Deflate
             int totalBytesRead = 0;
 
             // read the header on the first read
-            byte[] header = new byte[10];
-            int n = _stream.Read(header, 0, header.Length);
-
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (n == 0)
+            using (var header = ByteArrayPool.RentScope(10))
             {
-                return 0;
-            }
+                int n = _stream.Read(header);
 
-            if (n != 10)
-            {
-                throw new ZlibException("Not a valid GZIP stream.");
-            }
-
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-            {
-                throw new ZlibException("Bad GZIP header.");
-            }
-
-            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
-            _GzipMtime = TarHeader.Epoch.AddSeconds(timet);
-            totalBytesRead += n;
-            if ((header[3] & 0x04) == 0x04)
-            {
-                // read and discard extra field
-                n = _stream.Read(header, 0, 2); // 2-byte length field
-                totalBytesRead += n;
-
-                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
-                byte[] extra = new byte[extraLength];
-                n = _stream.Read(extra, 0, extra.Length);
-                if (n != extraLength)
+                // workitem 8501: handle edge case (decompress empty stream)
+                if (n == 0)
                 {
-                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+                    return 0;
                 }
-                totalBytesRead += n;
-            }
-            if ((header[3] & 0x08) == 0x08)
-            {
-                _GzipFileName = ReadZeroTerminatedString();
-            }
-            if ((header[3] & 0x10) == 0x010)
-            {
-                _GzipComment = ReadZeroTerminatedString();
-            }
-            if ((header[3] & 0x02) == 0x02)
-            {
-                Read(_buf1, 0, 1); // CRC16, ignore
-            }
 
-            return totalBytesRead;
+                if (n != 10)
+                {
+                    throw new ZlibException("Not a valid GZIP stream.");
+                }
+
+                if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+                {
+                    throw new ZlibException("Bad GZIP header.");
+                }
+
+                Int32 timet = DataConverter.LittleEndian.GetInt32(header.Array, 4);
+                _GzipMtime = TarHeader.Epoch.AddSeconds(timet);
+                totalBytesRead += n;
+                if ((header[3] & 0x04) == 0x04)
+                {
+                    // read and discard extra field
+                    n = _stream.Read(header.Array, 0, 2); // 2-byte length field
+                    totalBytesRead += n;
+
+                    Int16 extraLength = (Int16)(header[0] + header[1] * 256);
+                    using (var extra = ByteArrayPool.RentScope(extraLength))
+                    {
+                        n = _stream.Read(extra);
+                        if (n != extraLength)
+                        {
+                            throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+                        }
+                        totalBytesRead += n;
+                    }
+                }
+                if ((header[3] & 0x08) == 0x08)
+                {
+                    _GzipFileName = ReadZeroTerminatedString();
+                }
+                if ((header[3] & 0x10) == 0x010)
+                {
+                    _GzipComment = ReadZeroTerminatedString();
+                }
+                if ((header[3] & 0x02) == 0x02)
+                {
+                    Read(_buf1, 0, 1); // CRC16, ignore
+                }
+
+                return totalBytesRead;
+            }
         }
 
         public override Int32 Read(Byte[] buffer, Int32 offset, Int32 count)

src/SharpCompress/Compressors/LZMA/LZipStream.cs

@@ -1,153 +0,0 @@
-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/Crypto/IBlockCipher.cs

@@ -1,4 +1,6 @@
-namespace Org.BouncyCastle.Crypto
+using SharpCompress.IO;
+
+namespace Org.BouncyCastle.Crypto
 {
     /// <remarks>Base interface for a symmetric key block cipher.</remarks>
     public interface IBlockCipher
@@ -18,13 +20,11 @@
         bool IsPartialBlockOkay { get; }
 
         /// <summary>Process a block.</summary>
-        /// <param name="inBuf">The input buffer.</param>
-        /// <param name="inOff">The offset into <paramref>inBuf</paramref> that the input block begins.</param>
-        /// <param name="outBuf">The output buffer.</param>
-        /// <param name="outOff">The offset into <paramref>outBuf</paramref> to write the output block.</param>
+        /// <param name="input">The input buffer.</param>
+        /// <param name="output">The output buffer.</param>
         /// <exception cref="DataLengthException">If input block is wrong size, or outBuf too small.</exception>
         /// <returns>The number of bytes processed and produced.</returns>
-        int ProcessBlock(byte[] inBuf, int inOff, byte[] outBuf, int outOff);
+        int ProcessBlock(ByteArrayPoolScope input, ByteArrayPoolScope output);
 
         /// <summary>
         /// Reset the cipher to the same state as it was after the last init (if there was one).

src/SharpCompress/Crypto/RijndaelEngine.cs

@@ -1,5 +1,6 @@
 using System;
 using Org.BouncyCastle.Crypto.Parameters;
+using SharpCompress.IO;
 
 namespace Org.BouncyCastle.Crypto.Engines
 {
@@ -586,28 +587,24 @@ namespace Org.BouncyCastle.Crypto.Engines
             return BC / 2;
         }
 
-        public int ProcessBlock(
-            byte[] input,
-            int inOff,
-            byte[] output,
-            int outOff)
+        public int ProcessBlock(ByteArrayPoolScope input, ByteArrayPoolScope output)
         {
             if (workingKey == null)
             {
                 throw new InvalidOperationException("Rijndael engine not initialised");
             }
 
-            if ((inOff + (BC / 2)) > input.Length)
+            if ((input.Offset + (BC / 2)) > input.Count)
             {
                 throw new DataLengthException("input buffer too short");
             }
 
-            if ((outOff + (BC / 2)) > output.Length)
+            if ((output.Offset + (BC / 2)) > output.Count)
             {
                 throw new DataLengthException("output buffer too short");
             }
 
-            UnPackBlock(input, inOff);
+            UnPackBlock(input.Array, input.Offset);
 
             if (forEncryption)
             {
@@ -618,7 +615,7 @@ namespace Org.BouncyCastle.Crypto.Engines
                 DecryptBlock(workingKey);
             }
 
-            PackBlock(output, outOff);
+            PackBlock(output.Array, output.Offset);
 
             return BC / 2;
         }

src/SharpCompress/IO/ByteArrayPool.cs

@@ -0,0 +1,52 @@
+using System;
+#if !NO_BUFFERS
+using System.Buffers;
+#endif
+
+namespace SharpCompress.IO
+{
+    public static class ByteArrayPool
+    {
+#if !NO_BUFFERS
+        private static readonly ArrayPool<byte> POOL = ArrayPool<byte>.Create();
+#endif
+        public static ArraySegment<byte> Rent(int size)
+        {
+#if NO_BUFFERS
+            return new ArraySegment<byte>(new byte[size]);
+#else
+            return new ArraySegment<byte>(POOL.Rent(size), 0, size);
+#endif
+        }
+
+        public static byte[] RentWritable(int size)
+        {
+#if NO_BUFFERS
+            return new byte[size];
+#else
+            return POOL.Rent(size);
+#endif
+        }
+
+        public static ByteArrayPoolScope RentScope(int size)
+        {
+            return new ByteArrayPoolScope(Rent(size));
+        }
+
+
+        public static void Return(ArraySegment<byte> array)
+        {
+#if NO_BUFFERS
+#else
+            POOL.Return(array.Array);
+#endif
+        }
+        public static void Return(byte[] array)
+        {
+#if NO_BUFFERS
+#else
+            POOL.Return(array);
+#endif
+        }
+    }
+}

src/SharpCompress/IO/ByteArrayPoolScope.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace SharpCompress.IO
+{
+    public struct ByteArrayPoolScope : IDisposable
+    {
+        private readonly ArraySegment<byte> array;
+        private int? overridenSize;
+        public ByteArrayPoolScope(ArraySegment<byte> array)
+        {
+            this.array = array;
+            overridenSize = null;
+        }
+
+        public byte[] Array => array.Array;
+        public int Offset => array.Offset;
+        public int Count => overridenSize ?? array.Count;
+
+        public byte this[int index]
+        {
+            get { return Array[index]; }
+            set { Array[index] = value; }
+        }
+
+        public void Dispose()
+        {
+            ByteArrayPool.Return(array);
+        }
+
+        public void OverrideSize(int newSize)
+        {
+            overridenSize = newSize;
+        }
+    }
+}

src/SharpCompress/IO/ByteArrayPoolScopeExtensions.cs

@@ -0,0 +1,30 @@
+using System.IO;
+
+namespace SharpCompress.IO
+{
+    public static class ByteArrayPoolScopeExtensions
+    {
+        public static int Read(this Stream stream, ByteArrayPoolScope scope)
+        {
+            return stream.Read(scope.Array, scope.Offset, scope.Count);
+        }
+
+        public static ByteArrayPoolScope ReadScope(this BinaryReader stream, int count)
+        {
+            var scope = ByteArrayPool.RentScope(count);
+            int numRead = 0;
+            do
+            {
+                int n = stream.Read(scope.Array, numRead, count);
+                if (n == 0)
+                {
+                    break;
+                }
+                numRead += n;
+                count -= n;
+            } while (count > 0);
+            scope.OverrideSize(numRead);
+            return scope;
+        }
+    }
+}

src/SharpCompress/IO/MarkingBinaryReader.cs

@@ -26,7 +26,9 @@ namespace SharpCompress.IO
 
         public override int Read(byte[] buffer, int index, int count)
         {
-            throw new NotSupportedException();
+            int read = base.Read(buffer, index, count);
+            CurrentReadByteCount += read;
+            return read;
         }
 
         public override int Read(char[] buffer, int index, int count)
@@ -36,12 +38,18 @@ namespace SharpCompress.IO
 
         public override bool ReadBoolean()
         {
-            return ReadBytes(1).Single() != 0;
+            using (var b = this.ReadScope(1))
+            {
+                return b.Array.First() != 0;
+            }
         }
 
         public override byte ReadByte()
         {
-            return ReadBytes(1).Single();
+            using (var b = this.ReadScope(1))
+            {
+                return b.Array.First();
+            }
         }
 
         public override byte[] ReadBytes(int count)
@@ -79,17 +87,26 @@ namespace SharpCompress.IO
 
         public override short ReadInt16()
         {
-            return DataConverter.LittleEndian.GetInt16(ReadBytes(2), 0);
+            using (var b = this.ReadScope(2))
+            {
+                return DataConverter.LittleEndian.GetInt16(b.Array, 0);
+            }
         }
 
         public override int ReadInt32()
         {
-            return DataConverter.LittleEndian.GetInt32(ReadBytes(4), 0);
+            using (var b = this.ReadScope(4))
+            {
+                return DataConverter.LittleEndian.GetInt32(b.Array, 0);
+            }
         }
 
         public override long ReadInt64()
         {
-            return DataConverter.LittleEndian.GetInt64(ReadBytes(8), 0);
+            using (var b = this.ReadScope(8))
+            {
+                return DataConverter.LittleEndian.GetInt64(b.Array, 0);
+            }
         }
 
         public override sbyte ReadSByte()
@@ -109,17 +126,26 @@ namespace SharpCompress.IO
 
         public override ushort ReadUInt16()
         {
-            return DataConverter.LittleEndian.GetUInt16(ReadBytes(2), 0);
+            using (var b = this.ReadScope(2))
+            {
+                return DataConverter.LittleEndian.GetUInt16(b.Array, 0);
+            }
         }
 
         public override uint ReadUInt32()
         {
-            return DataConverter.LittleEndian.GetUInt32(ReadBytes(4), 0);
+            using (var b = this.ReadScope(4))
+            {
+                return DataConverter.LittleEndian.GetUInt32(b.Array, 0);
+            }
         }
 
         public override ulong ReadUInt64()
         {
-            return DataConverter.LittleEndian.GetUInt64(ReadBytes(8), 0);
+            using (var b = this.ReadScope(8))
+            {
+                return DataConverter.LittleEndian.GetUInt64(b.Array, 0);
+            }
         }
     }
 }

src/SharpCompress/Readers/ReaderFactory.cs

@@ -13,7 +13,6 @@ using SharpCompress.Readers.GZip;
 using SharpCompress.Readers.Rar;
 using SharpCompress.Readers.Tar;
 using SharpCompress.Readers.Zip;
-using SharpCompress.Compressors.LZMA;
 
 namespace SharpCompress.Readers
 {
@@ -65,18 +64,6 @@ 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,7 +9,6 @@ using SharpCompress.Compressors;
 using SharpCompress.Compressors.BZip2;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.IO;
-using SharpCompress.Compressors.LZMA;
 
 namespace SharpCompress.Readers.Tar
 {
@@ -39,10 +38,6 @@ namespace SharpCompress.Readers.Tar
                 {
                     return new GZipStream(stream, CompressionMode.Decompress);
                 }
-                case CompressionType.LZip:
-                {
-                    return new LZipStream(stream, CompressionMode.Decompress);
-                }
                 case CompressionType.None:
                 {
                     return stream;
@@ -92,19 +87,6 @@ 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/Utility.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using SharpCompress.IO;
 
 namespace SharpCompress
 {
@@ -137,37 +138,41 @@ namespace SharpCompress
 
         public static void Skip(this Stream source, long advanceAmount)
         {
-            byte[] buffer = new byte[32 * 1024];
-            int read = 0;
-            int readCount = 0;
-            do
+            using (var buffer = ByteArrayPool.RentScope(32 * 1024))
             {
-                readCount = buffer.Length;
-                if (readCount > advanceAmount)
+                int read = 0;
+                int readCount = 0;
+                do
                 {
-                    readCount = (int)advanceAmount;
-                }
-                read = source.Read(buffer, 0, readCount);
-                if (read <= 0)
-                {
-                    break;
-                }
-                advanceAmount -= read;
-                if (advanceAmount == 0)
-                {
-                    break;
+                    readCount = buffer.Count;
+                    if (readCount > advanceAmount)
+                    {
+                        readCount = (int)advanceAmount;
+                    }
+                    read = source.Read(buffer.Array, 0, readCount);
+                    if (read <= 0)
+                    {
+                        break;
+                    }
+                    advanceAmount -= read;
+                    if (advanceAmount == 0)
+                    {
+                        break;
+                    }
                 }
+                while (true);
             }
-            while (true);
         }
 
         public static void SkipAll(this Stream source)
         {
-            byte[] buffer = new byte[32 * 1024];
-            do
+            using (var buffer = ByteArrayPool.RentScope(32 * 1024))
             {
+                do
+                {
+                }
+                while (source.Read(buffer) > 0);
             }
-            while (source.Read(buffer, 0, buffer.Length) == buffer.Length);
         }
 
         public static DateTime DosDateToDateTime(UInt16 iDate, UInt16 iTime)
@@ -231,15 +236,17 @@ namespace SharpCompress
 
         public static long TransferTo(this Stream source, Stream destination)
         {
-            byte[] array = new byte[81920];
-            int count;
-            long total = 0;
-            while ((count = source.Read(array, 0, array.Length)) != 0)
+            using (var array = ByteArrayPool.RentScope(81920))
             {
-                total += count;
-                destination.Write(array, 0, count);
+                int count;
+                long total = 0;
+                while ((count = source.Read(array.Array, 0, array.Count)) != 0)
+                {
+                    total += count;
+                    destination.Write(array.Array, 0, count);
+                }
+                return total;
             }
-            return total;
         }
 
         public static bool ReadFully(this Stream stream, byte[] buffer)
@@ -261,14 +268,14 @@ namespace SharpCompress
         {
             return source.Replace('\0', ' ').Trim();
         }
-
-        public static bool BinaryEquals(this byte[] source, byte[] target)
+        
+        public static bool BinaryEquals(this ByteArrayPoolScope source, byte[] target)
         {
-            if (source.Length != target.Length)
+            if (source.Count != target.Length)
             {
                 return false;
             }
-            for (int i = 0; i < source.Length; ++i)
+            for (int i = 0; i < source.Count; ++i)
             {
                 if (source[i] != target[i])
                 {
@@ -277,10 +284,5 @@ namespace SharpCompress
             }
             return true;
         }
-
-        public static void CopyTo(this byte[] array, byte[] destination, int index)
-        {
-            Array.Copy(array, 0, destination, index, array.Length);
-        }
     }
 }

src/SharpCompress/project.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.15.2",
+    "version": "0.13.1",
     "title": "SharpCompress - Pure C# Decompression/Compression",
     "authors": [ "Adam Hathcock" ],
     "language": "en-US",
@@ -13,19 +13,25 @@
     },
     "buildOptions": {
         "warningsAsErrors": true,
-        "allowUnsafe": true,
-        "keyFile": "../../SharpCompress.snk"
+        "allowUnsafe": true
     },
     "frameworks": {
-        "net35": {
-        },
         "net40": {
+            "buildOptions": {
+                "define": [ "NO_BUFFERS" ]
+            }
         },
         "net45": {
+            "dependencies": {
+                "System.Buffers": "4.0.0"
+            },
+            "frameworkAssemblies": {
+                "System.Runtime": { "type": "build" }
+            }
         },
         ".NETPortable,Version=v4.0,Profile=Profile328": {
             "buildOptions": {
-                "define": [ "NO_FILE", "NO_CRYPTO", "SILVERLIGHT" ]
+                "define": [ "NO_FILE", "NO_CRYPTO", "SILVERLIGHT", "NO_BUFFERS" ]
             },
             "frameworkAssemblies": {
                 "mscorlib": { "type": "build" },
@@ -35,7 +41,7 @@
         },
         ".NETPortable,Version=v4.5,Profile=Profile259": {
             "buildOptions": {
-                "define": [ "NO_FILE", "NO_CRYPTO", "SILVERLIGHT" ]
+                "define": [ "NO_FILE", "NO_CRYPTO", "SILVERLIGHT", "NO_BUFFERS" ]
             },
             "frameworkAssemblies": {
                 "System": { "type": "build" },
@@ -53,7 +59,7 @@
         },
         "netstandard1.0": {
             "buildOptions": {
-                "define": [ "NO_FILE", "NO_CRYPTO" ]
+                "define": [ "NO_FILE", "NO_CRYPTO", "NO_BUFFERS" ]
             },
             "dependencies": {
                 "System.Collections": "4.0.11",
@@ -65,8 +71,24 @@
                 "System.Text.Encoding.Extensions": "4.0.11"
             }
         },
+        "netstandard1.1": {
+            "buildOptions": {
+                "define": [ "NO_FILE", "NO_CRYPTO" ]
+            },
+            "dependencies": {
+                "System.Buffers": "4.0.0",
+                "System.Collections": "4.0.11",
+                "System.Diagnostics.Debug": "4.0.11",
+                "System.IO": "4.1.0",
+                "System.Linq": "4.1.0",
+                "System.Resources.ResourceManager": "4.0.1",
+                "System.Runtime.Extensions": "4.1.0",
+                "System.Text.Encoding.Extensions": "4.0.11"
+            }
+        },
         "netstandard1.3": {
             "dependencies": {
+                "System.Buffers": "4.0.0",
                 "System.Collections": "4.0.11",
                 "System.Diagnostics.Debug": "4.0.11",
                 "System.IO": "4.1.0",

test/SharpCompress.Test/GZip/GZipArchiveTests.cs

@@ -46,7 +46,7 @@ namespace SharpCompress.Test
         [Fact]
         public void GZip_Archive_NoAdd()
         {
-            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg", "test.jpg");
+            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg\\test.jpg");
             ResetScratch();
             using (Stream stream = File.Open(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"), FileMode.Open))
             using (var archive = GZipArchive.Open(stream))
@@ -55,47 +55,5 @@ 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/TarArchiveTests.cs

@@ -115,7 +115,7 @@ namespace SharpCompress.Test
         [Fact]
         public void Tar_Random_Write_Add()
         {
-            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg","test.jpg");
+            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg\\test.jpg");
             string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Tar.mod.tar");
             string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.mod.tar");
             string modified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar");

test/SharpCompress.Test/Tar/TarReaderTests.cs

@@ -33,12 +33,6 @@ 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/TestBase.cs

@@ -210,26 +210,16 @@ namespace SharpCompress.Test
 
         protected void CompareArchivesByPath(string file1, string file2)
         {
-            //don't compare the order.  OS X reads files from the file system in a different order therefore makes the archive ordering different
-            var archive1Entries = new List<string>();
-            var archive2Entries = new List<string>();
             using (var archive1 = ReaderFactory.Open(File.OpenRead(file1)))
             using (var archive2 = ReaderFactory.Open(File.OpenRead(file2)))
             {
                 while (archive1.MoveToNextEntry())
                 {
                     Assert.True(archive2.MoveToNextEntry());
-                    archive1Entries.Add(archive1.Entry.Key);
-                    archive2Entries.Add(archive2.Entry.Key);
+                    Assert.Equal(archive1.Entry.Key, archive2.Entry.Key);
                 }
                 Assert.False(archive2.MoveToNextEntry());
             }
-            archive1Entries.Sort();
-            archive2Entries.Sort();
-            for (int i = 0; i < archive1Entries.Count; i++)
-            {
-                Assert.Equal(archive1Entries[i], archive2Entries[i]);
-            }
         }
 
         private static object lockObject = new object();

test/SharpCompress.Test/Zip/ZipArchiveTests.cs

@@ -25,6 +25,7 @@ namespace SharpCompress.Test
             ArchiveStreamRead("Zip.zipx");
         }
 
+
         [Fact]
         public void Zip_BZip2_Streamed_ArchiveStreamRead()
         {
@@ -129,18 +130,6 @@ 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()
         {
@@ -161,7 +150,7 @@ namespace SharpCompress.Test
         [Fact]
         public void Zip_Random_Write_Add()
         {
-            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg","test.jpg");
+            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg\\test.jpg");
             string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Zip.deflate.mod.zip");
             string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod.zip");
             string modified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod2.zip");
@@ -385,29 +374,6 @@ 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/Zip/ZipReaderTests.cs

@@ -14,13 +14,6 @@ namespace SharpCompress.Test
         {
             UseExtensionInsteadOfNameToVerify = true;
         }
-
-        [Fact]
-        public void Zip_Zip64_Streamed_Read()
-        {
-            Read("Zip.Zip64.zip", CompressionType.Deflate);
-        }
-
         [Fact]
         public void Zip_ZipX_Streamed_Read()
         {

test/SharpCompress.Test/project.json

@@ -1,8 +1,4 @@
 {
-    "buildOptions": {
-        "keyFile": "../../SharpCompress.snk"
-    },
-
     "testRunner": "xunit",
 
     "frameworks": {
@@ -18,7 +14,7 @@
     "dependencies": {
         "Microsoft.Extensions.PlatformAbstractions": "1.0.0",
         "SharpCompress": { "target" : "project"},
-        "xunit": "2.2.0-beta2-build3300",
+        "xunit": "2.2.0-beta3-build3402",
         "dotnet-test-xunit": "2.2.0-preview2-build1029"
     }
 }