Update build and mark for 0.28.3

Write ZIP64 End of Central Directory only if needed.

.github/workflows/dotnetcore.yml

@@ -12,7 +12,7 @@ jobs:
     - uses: actions/checkout@v1
     - uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: 5.0.101
+        dotnet-version: 5.0.300
     - run: dotnet run -p build/build.csproj
     - uses: actions/upload-artifact@v2
       with:

FORMATS.md

@@ -19,7 +19,6 @@
 | Tar.XZ                 | LZMA2                                             | Decompress          | TarArchive      | TarReader  | TarWriter (3) |
 | GZip (single file)     | DEFLATE                                           | Both                | GZipArchive     | GZipReader | GZipWriter    |
 | 7Zip (4)               | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate      | Decompress          | SevenZipArchive | N/A        | N/A           |
-| LZip (single file) (5) | LZip (LZMA)                                       | Both                | LZipArchive     | LZipReader | LZipWriter    |
 
 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/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading.

build/build.csproj

@@ -6,9 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Bullseye" Version="3.6.0" />
+    <PackageReference Include="Bullseye" Version="3.7.0" />
     <PackageReference Include="Glob" Version="1.1.8" />
-    <PackageReference Include="SimpleExec" Version="6.4.0" />
+    <PackageReference Include="SimpleExec" Version="7.0.0" />
   </ItemGroup>
 
 </Project>

global.json

@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "5.0.101"
+    "version": "5.0.300"
   }
 }

src/SharpCompress/Common/SevenZip/SevenZipEntry.cs

@@ -32,7 +32,7 @@ namespace SharpCompress.Common.SevenZip
 
         public override DateTime? ArchivedTime => null;
 
-        public override bool IsEncrypted => false;
+        public override bool IsEncrypted => FilePart.IsEncrypted;
 
         public override bool IsDirectory => FilePart.Header.IsDir;
 

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -102,5 +102,7 @@ namespace SharpCompress.Common.SevenZip
                     throw new NotImplementedException();
             }
         }
+
+        internal bool IsEncrypted => Folder!._coders.FindIndex(c => c._methodId._id == CMethodId.K_AES_ID) != -1;
     }
 }

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

@@ -63,6 +63,8 @@ namespace SharpCompress.Common.Zip.Headers
             var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
             if (zip64ExtraData != null)
             {
+                zip64ExtraData.Process(UncompressedSize, CompressedSize, RelativeOffsetOfEntryHeader, DiskNumberStart);
+
                 if (CompressedSize == uint.MaxValue)
                 {
                     CompressedSize = zip64ExtraData.CompressedSize;

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

@@ -53,6 +53,8 @@ namespace SharpCompress.Common.Zip.Headers
             var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
             if (zip64ExtraData != null)
             {
+                zip64ExtraData.Process(UncompressedSize, CompressedSize, 0, 0);
+
                 if (CompressedSize == uint.MaxValue)
                 {
                     CompressedSize = zip64ExtraData.CompressedSize;

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

@@ -66,46 +66,74 @@ namespace SharpCompress.Common.Zip.Headers
         public Zip64ExtendedInformationExtraField(ExtraDataType type, ushort length, byte[] dataBytes)
             : base(type, length, dataBytes)
         {
-            Process();
         }
 
-        private void Process()
+        // From the spec, values are only in the extradata if the standard
+        // value is set to 0xFFFFFFFF (or 0xFFFF for the Disk Start Number).
+        // Values, if present, must appear in the following order:
+        // - Original Size
+        // - Compressed Size
+        // - Relative Header Offset
+        // - Disk Start Number
+        public void Process(long uncompressedFileSize, long compressedFileSize, long relativeHeaderOffset, ushort diskNumber)
         {
-            if (DataBytes.Length >= 8)
+            var bytesRequired = ((uncompressedFileSize == uint.MaxValue) ? 8 : 0)
+                + ((compressedFileSize == uint.MaxValue) ? 8 : 0)
+                + ((relativeHeaderOffset == uint.MaxValue) ? 8 : 0)
+                + ((diskNumber == ushort.MaxValue) ? 4 : 0);
+            var currentIndex = 0;
+
+            if (bytesRequired > DataBytes.Length)
             {
-                UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                throw new ArchiveException("Zip64 extended information extra field is not large enough for the required information");
             }
 
-            if (DataBytes.Length >= 16)
+            if (uncompressedFileSize == uint.MaxValue)
             {
-                CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
             }
 
-            if (DataBytes.Length >= 24)
+            if (compressedFileSize == uint.MaxValue)
             {
-                RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
+                CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
             }
 
-            if (DataBytes.Length >= 28)
+            if (relativeHeaderOffset == uint.MaxValue)
             {
-                VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(24));
+                RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
             }
 
-            switch (DataBytes.Length)
+            if (diskNumber == ushort.MaxValue)
             {
-                case 8:
-                case 16:
-                case 24:
-                case 28:
-                    break;
-                default:
-                    throw new ArchiveException($"Unexpected size of of Zip64 extended information extra field: {DataBytes.Length}");
+                VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(currentIndex));
             }
         }
 
+        /// <summary>
+        /// Uncompressed file size. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
         public long UncompressedSize { get; private set; }
+
+        /// <summary>
+        /// Compressed file size. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
         public long CompressedSize { get; private set; }
+
+        /// <summary>
+        /// Relative offset of the entry header. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
         public long RelativeOffsetOfEntryHeader { get; private set; }
+
+        /// <summary>
+        /// Volume number. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFF value.
+        /// </summary>
         public uint VolumeNumber { get; private set; }
     }
 

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

@@ -105,6 +105,6 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal ZipFilePart Part { get; set; }
 
-        internal bool IsZip64 => CompressedSize == uint.MaxValue;
+        internal bool IsZip64 => CompressedSize >= uint.MaxValue;
     }
 }

src/SharpCompress/Polyfills/StreamExtensions.cs

@@ -1,18 +1,20 @@
 #if NET461 || NETSTANDARD2_0
 
+using System;
 using System.Buffers;
+using System.IO;
 
-namespace System.IO
+namespace SharpCompress
 {
-    public static class StreamExtensions
+    internal static class StreamExtensions
     {
-        public static int Read(this Stream stream, Span<byte> buffer)
+        internal static int Read(this Stream stream, Span<byte> buffer)
         {
             byte[] temp = ArrayPool<byte>.Shared.Rent(buffer.Length);
 
             try
             {
-                int read = stream.Read(buffer);
+                int read = stream.Read(temp, 0, buffer.Length);
 
                 temp.AsSpan(0, read).CopyTo(buffer);
 
@@ -24,7 +26,7 @@ namespace System.IO
             }
         }
 
-        public static void Write(this Stream stream, ReadOnlySpan<byte> buffer)
+        internal static void Write(this Stream stream, ReadOnlySpan<byte> buffer)
         {
             byte[] temp = ArrayPool<byte>.Shared.Rent(buffer.Length);
 

src/SharpCompress/Polyfills/StringExtensions.cs

@@ -1,15 +1,15 @@
 #if NET461 || NETSTANDARD2_0
 
-namespace System
+namespace SharpCompress
 {
-    public static class StringExtensions
+    internal static class StringExtensions
     {
-        public static bool EndsWith(this string text, char value)
+        internal static bool EndsWith(this string text, char value)
         {
             return text.Length > 0 && text[text.Length - 1] == value;
         }
 
-        public static bool Contains(this string text, char value)
+        internal static bool Contains(this string text, char value)
         {
             return text.IndexOf(value) > -1;
         }

src/SharpCompress/SharpCompress.csproj

@@ -2,9 +2,9 @@
   <PropertyGroup>
     <AssemblyTitle>SharpCompress - Pure C# Decompression/Compression</AssemblyTitle>
     <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>0.28.0</VersionPrefix>
-    <AssemblyVersion>0.28.0</AssemblyVersion>
-    <FileVersion>0.28.0</FileVersion>
+    <VersionPrefix>0.28.3</VersionPrefix>
+    <AssemblyVersion>0.28.3</AssemblyVersion>
+    <FileVersion>0.28.3</FileVersion>
     <Authors>Adam Hathcock</Authors>
     <TargetFrameworks>netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0</TargetFrameworks>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
@@ -35,7 +35,8 @@
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
     <PackageReference Include="System.Text.Encoding.CodePages" Version="5.0.0" />
-    <PackageReference Include="System.Memory" Version="4.5.4" />
+    <PackageReference Include="System.Memory" Version="4.5.3" />
+    <PackageReference Include="System.Buffers" Version="4.4.0" />
   </ItemGroup>
 
 </Project>

src/SharpCompress/Utility.cs

@@ -280,7 +280,22 @@ namespace SharpCompress
         {
             return ArrayPool<byte>.Shared.Rent(81920);
         }
-
+        
+        public static bool ReadFully(this Stream stream, byte[] buffer)
+        {
+            int total = 0;
+            int read;
+            while ((read = stream.Read(buffer, total, buffer.Length - total)) > 0)
+            {
+                total += read;
+                if (total >= buffer.Length)
+                {
+                    return true;
+                }
+            }
+            return (total >= buffer.Length);
+        }
+        
         public static bool ReadFully(this Stream stream, Span<byte> buffer)
         {
             int total = 0;

src/SharpCompress/Writers/Zip/ZipWriter.cs

@@ -238,13 +238,13 @@ namespace SharpCompress.Writers.Zip
         private void WriteEndRecord(ulong size)
         {
 
-            var zip64 = isZip64 || entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;
+            var zip64EndOfCentralDirectoryNeeded = entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;
 
             var sizevalue = size >= uint.MaxValue ? uint.MaxValue : (uint)size;
             var streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streamPosition;
 
             Span<byte> intBuf = stackalloc byte[8];
-            if (zip64)
+            if (zip64EndOfCentralDirectoryNeeded)
             {
                 var recordlen = 2 + 2 + 4 + 4 + 8 + 8 + 8 + 8;
 
@@ -281,8 +281,7 @@ namespace SharpCompress.Writers.Zip
                 BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 1);
                 OutputStream.Write(intBuf.Slice(0, 4)); // Number of disks
 
-                streamPosition += recordlen + (4 + 4 + 8 + 4);
-                streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streampositionvalue;
+                streamPosition += 4 + 8 + recordlen + (4 + 4 + 8 + 4);
             }
 
             // Write normal end of central directory record

tests/SharpCompress.Test/SharpCompress.Test.csproj

@@ -12,7 +12,7 @@
     <ProjectReference Include="..\..\src\SharpCompress\SharpCompress.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

tests/SharpCompress.Test/Zip/ZipArchiveTests.cs

@@ -576,5 +576,23 @@ namespace SharpCompress.Test.Zip
                 Assert.Equal(1, count);
             }
         }
+
+        [Fact]
+        public void Zip_Zip64_CompressedSizeExtraOnly_Read()
+        {
+            string zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.zip64.compressedonly.zip");
+
+            using (ZipArchive za = ZipArchive.Open(zipPath))
+            {
+                var firstEntry = za.Entries.First(x => x.Key == "test/test.txt");
+
+                using (var memoryStream = new MemoryStream())
+                using (var firstStream = firstEntry.OpenEntryStream())
+                {
+                    firstStream.CopyTo(memoryStream);
+                    Assert.Equal(15, memoryStream.Length);
+                }
+            }
+        }
     }
 }

tests/SharpCompress.Test/Zip/ZipReaderTests.cs

@@ -268,6 +268,34 @@ namespace SharpCompress.Test.Zip
             }
             VerifyFiles();
         }
+        
+        [Fact]
+        public void Zip_Deflate_ZipCrypto_Read()
+        {
+            int count = 0;
+            using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "zipcrypto.zip")))
+            using (var reader = ZipReader.Open(stream, new ReaderOptions()
+                                                       {
+                                                           Password = "test"
+                                                       }))
+            {
+                while (reader.MoveToNextEntry())
+                {
+                    if (!reader.Entry.IsDirectory)
+                    {
+                        Assert.Equal(CompressionType.None, reader.Entry.CompressionType);
+                        reader.WriteEntryToDirectory(SCRATCH_FILES_PATH,
+                                                     new ExtractionOptions()
+                                                     {
+                                                         ExtractFullPath = true,
+                                                         Overwrite = true
+                                                     });
+                        count++;
+                    }
+                }
+            }
+            Assert.Equal(8, count);
+        }
 
         [Fact]
         public void TestSharpCompressWithEmptyStream()