Tag for 0.25.0 and update packages

Merge pull request #500 from Erior/Issue_86
ZipReader/StreamingZipReaderFactory fails for archive entries which are uncompressed files in ZIP format #86
2026-02-08 05:27:04 +00:00 · 2020-04-03 08:25:43 +01:00 · 2020-01-17 09:38:19 +00:00 · 2020-01-16 22:08:48 +01:00 · 2020-01-03 09:24:08 +00:00 · 2020-01-03 09:22:51 +00:00
40 changed files with 384 additions and 1678 deletions
--- a/.github/workflows/dotnetcore.yml
+++ b/.github/workflows/dotnetcore.yml
@@ -1,5 +1,4 @@
-name: Build and Test CaseFunnel
-
+name: SharpCompress
 on: [push]

 jobs:
--- a/README.md
+++ b/README.md
@@ -7,8 +7,8 @@ The major feature is support for non-seekable streams so large files can be proc
 AppVeyor Build -
 [![Build status](https://ci.appveyor.com/api/projects/status/voxg971oemmvxh1e/branch/master?svg=true)](https://ci.appveyor.com/project/adamhathcock/sharpcompress/branch/master)

-Circle CI Build -
-[![CircleCI](https://circleci.com/gh/adamhathcock/sharpcompress.svg?style=svg)](https://circleci.com/gh/adamhathcock/sharpcompress)
+GitHub Actions Build -
+[![GitHubActions](https://github.com/adamhathcock/sharpcompress/workflows/SharpCompress/badge.svg)](https://circleci.com/gh/adamhathcock/sharpcompress)

 ## Need Help?

--- a/src/SharpCompress/Common/ArchiveEncoding.cs
+++ b/src/SharpCompress/Common/ArchiveEncoding.cs
@@ -67,4 +67,4 @@ namespace SharpCompress.Common
            return CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
        }
    }
-}
+}
--- a/src/SharpCompress/Common/GZip/GZipFilePart.cs
+++ b/src/SharpCompress/Common/GZip/GZipFilePart.cs
@@ -1,11 +1,10 @@
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
-using SharpCompress.Converters;
-using System.Text;

 namespace SharpCompress.Common.GZip
 {
@@ -60,7 +59,7 @@ namespace SharpCompress.Common.GZip
                throw new ZlibException("Bad GZIP header.");
            }

-            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
+            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
            DateModified = TarHeader.EPOCH.AddSeconds(timet);
            if ((header[3] & 0x04) == 0x04)
            {
@@ -69,7 +68,7 @@ namespace SharpCompress.Common.GZip

                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
                byte[] extra = new byte[extraLength];
-                
+
                if (!stream.ReadFully(extra))
                {
                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
@@ -117,4 +116,4 @@ namespace SharpCompress.Common.GZip
            return ArchiveEncoding.Decode(buffer);
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
+++ b/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
@@ -50,10 +50,10 @@ namespace SharpCompress.Common.Rar
            if (sizeToRead > 0)
            {
                int alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
+                byte[] cipherText = new byte[RarRijndael.CRYPTO_BLOCK_SIZE];
                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);
@@ -93,4 +93,4 @@ namespace SharpCompress.Common.Rar
            base.Dispose(disposing);
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/RarRijndael.cs
+++ b/src/SharpCompress/Common/Rar/RarRijndael.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Security.Cryptography;
 using System.Text;
 using SharpCompress.Crypto;
@@ -89,19 +88,20 @@ namespace SharpCompress.Common.Rar
        public byte[] ProcessBlock(byte[] cipherText)
        {
            var plainText = new byte[CRYPTO_BLOCK_SIZE];
-            var decryptedBytes = new List<byte>();
+            byte[] decryptedBytes = new byte[CRYPTO_BLOCK_SIZE];
            _rijndael.ProcessBlock(cipherText, 0, plainText, 0);

-            for (int j = 0; j < plainText.Length; j++)
+            for (int j = 0; j < CRYPTO_BLOCK_SIZE; j++)
            {
-                decryptedBytes.Add((byte) (plainText[j] ^ _aesInitializationVector[j%16])); //32:114, 33:101
+                decryptedBytes[j] = (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;
        }

        public void Dispose()
--- a/src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs
+++ b/src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs
@@ -22,7 +22,7 @@ namespace SharpCompress.Common.SevenZip
        internal List<long> _packStreamStartPositions = new List<long>();
        internal List<int> _folderStartFileIndex = new List<int>();
        internal List<int> _fileIndexToFolderIndexMap = new List<int>();
-        
+
        internal IPasswordProvider PasswordProvider { get; }

        public ArchiveDatabase(IPasswordProvider passwordProvider)
@@ -152,13 +152,14 @@ namespace SharpCompress.Common.SevenZip
        {
            int packStreamIndex = folder._firstPackStreamId;
            long folderStartPackPos = GetFolderStreamPos(folder, 0);
-            List<long> packSizes = new List<long>();
-            for (int j = 0; j < folder._packStreams.Count; j++)
+            int count = folder._packStreams.Count;
+            long[] packSizes = new long[count];
+            for (int j = 0; j < count; j++)
            {
-                packSizes.Add(_packSizes[packStreamIndex + j]);
+                packSizes[j] = _packSizes[packStreamIndex + j];
            }

-            return DecoderStreamHelper.CreateDecoderStream(stream, folderStartPackPos, packSizes.ToArray(), folder, pw);
+            return DecoderStreamHelper.CreateDecoderStream(stream, folderStartPackPos, packSizes, folder, pw);
        }

        private long GetFolderPackStreamSize(int folderIndex, int streamIndex)
@@ -179,4 +180,4 @@ namespace SharpCompress.Common.SevenZip
            return 0;
        }
    }
-}
+}
--- a/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
+++ b/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
@@ -1449,13 +1449,14 @@ namespace SharpCompress.Common.SevenZip
                CFolder folderInfo = db._folders[folderIndex];
                int packStreamIndex = db._folders[folderIndex]._firstPackStreamId;
                long folderStartPackPos = db.GetFolderStreamPos(folderInfo, 0);
-                List<long> packSizes = new List<long>();
-                for (int j = 0; j < folderInfo._packStreams.Count; j++)
+                var count = folderInfo._packStreams.Count;
+                long[] packSizes = new long[count];
+                for (int j = 0; j < count; j++)
                {
-                    packSizes.Add(db._packSizes[packStreamIndex + j]);
+                    packSizes[j] = db._packSizes[packStreamIndex + j];
                }

-                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(), folderInfo,
+                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes, folderInfo,
                                                            db.PasswordProvider);
                _cachedStreams.Add(folderIndex, s);
            }
@@ -1553,15 +1554,16 @@ namespace SharpCompress.Common.SevenZip
                int packStreamIndex = db._folders[folderIndex]._firstPackStreamId;
                long folderStartPackPos = db.GetFolderStreamPos(folderInfo, 0);

-                List<long> packSizes = new List<long>();
-                for (int j = 0; j < folderInfo._packStreams.Count; j++)
+                var count = folderInfo._packStreams.Count;
+                long[] packSizes = new long[count];
+                for (int j = 0; j < count; j++)
                {
-                    packSizes.Add(db._packSizes[packStreamIndex + j]);
+                    packSizes[j] = db._packSizes[packStreamIndex + j];
                }

                // TODO: If the decoding fails the last file may be extracted incompletely. Delete it?

-                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(),
+                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes,
                                                                   folderInfo, db.PasswordProvider);
                byte[] buffer = new byte[4 << 10];
                for (;;)
--- a/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
+++ b/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
@@ -1,7 +1,7 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
 using System.Text;
-using SharpCompress.Converters;

 namespace SharpCompress.Common.Tar.Headers
 {
@@ -49,7 +49,7 @@ namespace SharpCompress.Common.Tar.Headers
            }
            else
            {
-                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 0, 100);
+                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 100);
                WriteOctalBytes(Size, buffer, 124, 12);
                var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
                WriteOctalBytes(time, buffer, 136, 12);
@@ -57,11 +57,10 @@ namespace SharpCompress.Common.Tar.Headers

                if (Size >= 0x1FFFFFFFF)
                {
-                    byte[] bytes = DataConverter.BigEndian.GetBytes(Size);
-                    var bytes12 = new byte[12];
-                    bytes.CopyTo(bytes12, 12 - bytes.Length);
+                    Span<byte> bytes12 = stackalloc byte[12];
+                    BinaryPrimitives.WriteInt64BigEndian(bytes12.Slice(4), Size);
                    bytes12[0] |= 0x80;
-                    bytes12.CopyTo(buffer, 124);
+                    bytes12.CopyTo(buffer.AsSpan(124));
                }
            }

@@ -176,8 +175,9 @@ namespace SharpCompress.Common.Tar.Headers
        {
            if ((buffer[124] & 0x80) == 0x80) // if size in binary
            {
-                return DataConverter.BigEndian.GetInt64(buffer, 0x80);
+                return BinaryPrimitives.ReadInt64BigEndian(buffer.AsSpan(0x80));
            }
+
            return ReadAsciiInt64Base8(buffer, 124, 11);
        }

@@ -192,15 +192,11 @@ namespace SharpCompress.Common.Tar.Headers
            return buffer;
        }

-        private static void WriteStringBytes(byte[] name, byte[] buffer, int offset, int length)
+        private static void WriteStringBytes(ReadOnlySpan<byte> name, Span<byte> buffer, int length)
        {
+            name.CopyTo(buffer);
            int i = Math.Min(length, name.Length);
-            Buffer.BlockCopy(name, 0, buffer, offset, i);
-            // if Span<byte>.Fill can be used, it is more efficient
-            for (; i < length; ++i)
-            {
-                buffer[offset + i] = 0;
-            }
+            buffer.Slice(i, length - i).Fill(0);
        }

        private static void WriteStringBytes(string name, byte[] buffer, int offset, int length)
--- a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs
+++ b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Buffers.Binary;
 using System.Text;
-using SharpCompress.Converters;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -76,34 +76,34 @@ namespace SharpCompress.Common.Zip.Headers
            switch (DataBytes.Length)
            {
                case 4:
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 0);
+                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes);
                    return;
                case 8:
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
                    return;
                case 12:
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 8);
+                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(8));
                    return;
                case 16:
-                     UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                     CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
                    return;
                case 20:
-                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 16);
+                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(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);
+                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(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);
+                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
+                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(24));
                    return;
                default:
                throw new ArchiveException("Unexpected size of of Zip64 extended information extra field");
@@ -132,7 +132,7 @@ namespace SharpCompress.Common.Zip.Headers
                case ExtraDataType.Zip64ExtendedInformationExtraField:
                    return new Zip64ExtendedInformationExtraField
                            (
-                                type, 
+                                type,
                                length,
                                extraData
                           );
@@ -146,4 +146,4 @@ namespace SharpCompress.Common.Zip.Headers
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Zip/Headers/ZipFileEntry.cs
+++ b/src/SharpCompress/Common/Zip/Headers/ZipFileEntry.cs
@@ -1,8 +1,7 @@
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
-using SharpCompress.Converters;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -30,7 +29,7 @@ namespace SharpCompress.Common.Zip.Headers
                       && Name.EndsWith("\\");
            }
        }
-        
+
        internal Stream PackedStream { get; set; }

        internal ArchiveEncoding ArchiveEncoding { get; }
@@ -65,7 +64,7 @@ namespace SharpCompress.Common.Zip.Headers

            return encryptionData;
        }
-        
+
        internal WinzipAesEncryptionData WinzipAesEncryptionData { get; set; }

        internal ushort LastModifiedDate { get; set; }
@@ -78,13 +77,13 @@ namespace SharpCompress.Common.Zip.Headers
        {
            for (int i = 0; i < extra.Length - 4;)
            {
-                ExtraDataType type = (ExtraDataType)DataConverter.LittleEndian.GetUInt16(extra, i);
+                ExtraDataType type = (ExtraDataType)BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i));
                if (!Enum.IsDefined(typeof(ExtraDataType), type))
                {
                    type = ExtraDataType.NotImplementedExtraData;
                }

-                ushort length = DataConverter.LittleEndian.GetUInt16(extra, i + 2);
+                ushort length = BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i + 2));

                // 7zip has this same kind of check to ignore extras blocks that don't conform to the standard 2-byte ID, 2-byte length, N-byte value.
                // CPP/7Zip/Zip/ZipIn.cpp: CInArchive::ReadExtra
--- a/src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs
+++ b/src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs
@@ -54,14 +54,30 @@ namespace SharpCompress.Common.Zip
                //entry could be zero bytes so we need to know that.
                if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
                {
-                    bool isRecording = rewindableStream.IsRecording;
-                    if (!isRecording)
+                    var local_header = ((LocalEntryHeader)header);
+
+                    // If we have CompressedSize, there is data to be read
+                    if( local_header.CompressedSize > 0 )
                    {
-                        rewindableStream.StartRecording();
+                        header.HasData = true;
+                    } // Check if zip is streaming ( Length is 0 and is declared in PostDataDescriptor )
+                    else if( local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor) )
+                    {
+                        bool isRecording = rewindableStream.IsRecording;
+                        if (!isRecording)
+                        {
+                            rewindableStream.StartRecording();
+                        }
+                        uint nextHeaderBytes = reader.ReadUInt32();
+
+                        // Check if next data is PostDataDescriptor, streamed file with 0 length
+                        header.HasData = !IsHeader(nextHeaderBytes);
+                        rewindableStream.Rewind(!isRecording);
+                    }
+                    else // We are not streaming and compressed size is 0, we have no data
+                    {
+                        header.HasData = false;
                    }
-                    uint nextHeaderBytes = reader.ReadUInt32();
-                    header.HasData = !IsHeader(nextHeaderBytes);
-                    rewindableStream.Rewind(!isRecording);
                }
                yield return header;
            }
--- a/src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs
+++ b/src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs
@@ -1,7 +1,7 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
 using System.Security.Cryptography;
-using SharpCompress.Converters;

 namespace SharpCompress.Common.Zip
 {
@@ -118,7 +118,7 @@ namespace SharpCompress.Common.Zip
                                  : bytesRemaining;

            // update the counter
-            DataConverter.LittleEndian.PutBytes(_counter, 0, _nonce++);
+            BinaryPrimitives.WriteInt32LittleEndian(_counter, _nonce++);

            // Determine if this is the final block
            if ((bytesToRead == bytesRemaining) && (_totalBytesLeftToRead == 0))
--- a/src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs
+++ b/src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Buffers.Binary;
 using System.Security.Cryptography;
-using SharpCompress.Converters;

 namespace SharpCompress.Common.Zip
 {
@@ -62,10 +62,10 @@ namespace SharpCompress.Common.Zip
            IvBytes = rfc2898.GetBytes(KeySizeInBytes);
            _generatedVerifyValue = rfc2898.GetBytes(2);

-            short verify = DataConverter.LittleEndian.GetInt16(_passwordVerifyValue, 0);
+            short verify = BinaryPrimitives.ReadInt16LittleEndian(_passwordVerifyValue);
            if (_password != null)
            {
-                short generated = DataConverter.LittleEndian.GetInt16(_generatedVerifyValue, 0);
+                short generated = BinaryPrimitives.ReadInt16LittleEndian(_generatedVerifyValue);
                if (verify != generated)
                {
                    throw new InvalidFormatException("bad password");
--- a/src/SharpCompress/Common/Zip/ZipFilePart.cs
+++ b/src/SharpCompress/Common/Zip/ZipFilePart.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common.Zip.Headers;
@@ -8,7 +9,6 @@ using SharpCompress.Compressors.Deflate;
 using SharpCompress.Compressors.Deflate64;
 using SharpCompress.Compressors.LZMA;
 using SharpCompress.Compressors.PPMd;
-using SharpCompress.Converters;
 using SharpCompress.IO;

 namespace SharpCompress.Common.Zip
@@ -108,19 +108,19 @@ namespace SharpCompress.Common.Zip
                    {
                        throw new InvalidFormatException("Winzip data length is not 7.");
                    }
-                    ushort compressedMethod = DataConverter.LittleEndian.GetUInt16(data.DataBytes, 0);
+                    ushort compressedMethod = BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes);

                    if (compressedMethod != 0x01 && compressedMethod != 0x02)
                    {
                        throw new InvalidFormatException("Unexpected vendor version number for WinZip AES metadata");
                    }

-                    ushort vendorId = DataConverter.LittleEndian.GetUInt16(data.DataBytes, 2);
+                    ushort vendorId = BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes.AsSpan(2));
                    if (vendorId != 0x4541)
                    {
                        throw new InvalidFormatException("Unexpected vendor ID for WinZip AES metadata");
                    }
-                    return CreateDecompressionStream(stream, (ZipCompressionMethod)DataConverter.LittleEndian.GetUInt16(data.DataBytes, 5));
+                    return CreateDecompressionStream(stream, (ZipCompressionMethod)BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes.AsSpan(5)));
                }
                default:
                {
@@ -142,7 +142,7 @@ namespace SharpCompress.Common.Zip
                && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
                || Header.IsZip64)
            {
-                plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close    
+                plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close
            }
            else
            {
@@ -182,4 +182,4 @@ namespace SharpCompress.Common.Zip
            return plainStream;
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/ADC/ADCBase.cs
+++ b/src/SharpCompress/Compressors/ADC/ADCBase.cs
@@ -65,16 +65,16 @@ namespace SharpCompress.Compressors.ADC
            }
        }

-        private static int GetOffset(byte[] chunk, int position)
+        private static int GetOffset(ReadOnlySpan<byte> chunk)
        {
-            switch (GetChunkType(chunk[position]))
+            switch (GetChunkType(chunk[0]))
            {
                case PLAIN:
                    return 0;
                case TWO_BYTE:
-                    return ((chunk[position] & 0x03) << 8) + chunk[position + 1];
+                    return ((chunk[0] & 0x03) << 8) + chunk[1];
                case THREE_BYTE:
-                    return (chunk[position + 1] << 8) + chunk[position + 2];
+                    return (chunk[1] << 8) + chunk[2];
                default:
                    return -1;
            }
@@ -116,7 +116,7 @@ namespace SharpCompress.Compressors.ADC
            byte[] buffer = new byte[bufferSize];
            int outPosition = 0;
            bool full = false;
-            MemoryStream tempMs;
+            Span<byte> temp = stackalloc byte[3];

            while (position < input.Length)
            {
@@ -142,11 +142,10 @@ namespace SharpCompress.Compressors.ADC
                        position += chunkSize + 1;
                        break;
                    case TWO_BYTE:
-                        tempMs = new MemoryStream();
                        chunkSize = GetChunkSize((byte)readByte);
-                        tempMs.WriteByte((byte)readByte);
-                        tempMs.WriteByte((byte)input.ReadByte());
-                        offset = GetOffset(tempMs.ToArray(), 0);
+                        temp[0] = (byte)readByte;
+                        temp[1] = (byte)input.ReadByte();
+                        offset = GetOffset(temp);
                        if (outPosition + chunkSize > bufferSize)
                        {
                            full = true;
@@ -173,12 +172,11 @@ namespace SharpCompress.Compressors.ADC
                        }
                        break;
                    case THREE_BYTE:
-                        tempMs = new MemoryStream();
                        chunkSize = GetChunkSize((byte)readByte);
-                        tempMs.WriteByte((byte)readByte);
-                        tempMs.WriteByte((byte)input.ReadByte());
-                        tempMs.WriteByte((byte)input.ReadByte());
-                        offset = GetOffset(tempMs.ToArray(), 0);
+                        temp[0] = (byte)readByte;
+                        temp[1] = (byte)input.ReadByte();
+                        temp[2] = (byte)input.ReadByte();
+                        offset = GetOffset(temp);
                        if (outPosition + chunkSize > bufferSize)
                        {
                            full = true;
@@ -217,4 +215,4 @@ namespace SharpCompress.Compressors.ADC
            return position - start;
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/Deflate/GZipStream.cs
+++ b/src/SharpCompress/Compressors/Deflate/GZipStream.cs
@@ -27,9 +27,8 @@
 // ------------------------------------------------------------------

 using System;
+using System.Buffers.Binary;
 using System.IO;
-using SharpCompress.Common;
-using SharpCompress.Converters;
 using System.Text;

 namespace SharpCompress.Compressors.Deflate
@@ -442,7 +441,7 @@ namespace SharpCompress.Compressors.Deflate
            }
            TimeSpan delta = LastModified.Value - UNIX_EPOCH;
            var timet = (Int32)delta.TotalSeconds;
-            DataConverter.LittleEndian.PutBytes(header, i, timet);
+            BinaryPrimitives.WriteInt32LittleEndian(header.AsSpan(i), timet);
            i += 4;

            // xflg
@@ -476,4 +475,4 @@ namespace SharpCompress.Compressors.Deflate
            return header.Length; // bytes written
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs
+++ b/src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs
@@ -25,11 +25,10 @@
 // ------------------------------------------------------------------

 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Common;
 using SharpCompress.Common.Tar.Headers;
-using SharpCompress.Converters;
 using System.Text;

 namespace SharpCompress.Compressors.Deflate
@@ -244,10 +243,12 @@ namespace SharpCompress.Compressors.Deflate
                    if (_wantCompress)
                    {
                        // Emit the GZIP trailer: CRC32 and  size mod 2^32
-                        int c1 = crc.Crc32Result;
-                        _stream.Write(DataConverter.LittleEndian.GetBytes(c1), 0, 4);
+                        byte[] intBuf = new byte[4];
+                        BinaryPrimitives.WriteInt32LittleEndian(intBuf, crc.Crc32Result);
+                        _stream.Write(intBuf, 0, 4);
                        int c2 = (Int32)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
-                        _stream.Write(DataConverter.LittleEndian.GetBytes(c2), 0, 4);
+                        BinaryPrimitives.WriteInt32LittleEndian(intBuf, c2);
+                        _stream.Write(intBuf, 0, 4);
                    }
                    else
                    {
@@ -293,9 +294,9 @@ namespace SharpCompress.Compressors.Deflate
                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
                        }

-                        Int32 crc32_expected = DataConverter.LittleEndian.GetInt32(trailer, 0);
+                        Int32 crc32_expected = BinaryPrimitives.ReadInt32LittleEndian(trailer);
                        Int32 crc32_actual = crc.Crc32Result;
-                        Int32 isize_expected = DataConverter.LittleEndian.GetInt32(trailer, 4);
+                        Int32 isize_expected = BinaryPrimitives.ReadInt32LittleEndian(trailer.AsSpan(4));
                        Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);

                        if (crc32_actual != crc32_expected)
@@ -446,7 +447,7 @@ namespace SharpCompress.Compressors.Deflate
                throw new ZlibException("Bad GZIP header.");
            }

-            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
+            Int32 timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
            _GzipMtime = TarHeader.EPOCH.AddSeconds(timet);
            totalBytesRead += n;
            if ((header[3] & 0x04) == 0x04)
@@ -647,4 +648,4 @@ namespace SharpCompress.Compressors.Deflate
            Undefined
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/LZMA/LZipStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/LZipStream.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
-using SharpCompress.Converters;
 using SharpCompress.Crypto;
 using SharpCompress.IO;

@@ -58,16 +58,17 @@ namespace SharpCompress.Compressors.LZMA
                    crc32Stream.WrappedStream.Dispose();
                    crc32Stream.Dispose();
                    var compressedCount = _countingWritableSubStream.Count;
-                    
-                    var bytes = DataConverter.LittleEndian.GetBytes(crc32Stream.Crc);
-                    _countingWritableSubStream.Write(bytes, 0, bytes.Length);

-                    bytes = DataConverter.LittleEndian.GetBytes(_writeCount);
-                    _countingWritableSubStream.Write(bytes, 0, bytes.Length);
+                    byte[] intBuf = new byte[8];
+                    BinaryPrimitives.WriteUInt32LittleEndian(intBuf, crc32Stream.Crc);
+                    _countingWritableSubStream.Write(intBuf, 0, 4);
+
+                    BinaryPrimitives.WriteInt64LittleEndian(intBuf, _writeCount);
+                    _countingWritableSubStream.Write(intBuf, 0, 8);

                    //total with headers
-                    bytes = DataConverter.LittleEndian.GetBytes(compressedCount + 6 + 20);
-                    _countingWritableSubStream.Write(bytes, 0, bytes.Length);
+                    BinaryPrimitives.WriteUInt64LittleEndian(intBuf, compressedCount + 6 + 20);
+                    _countingWritableSubStream.Write(intBuf, 0, 8);
                }
                _finished = true;
            }
@@ -101,7 +102,7 @@ namespace SharpCompress.Compressors.LZMA
        {
            _stream.Flush();
        }
-    
+
        // TODO: Both Length and Position are sometimes feasible, but would require
        // reading the output length when we initialize.
        public override long Length => throw new NotImplementedException();
--- a/src/SharpCompress/Compressors/LZMA/LzmaEncoder.cs
+++ b/src/SharpCompress/Compressors/LZMA/LzmaEncoder.cs
@@ -996,7 +996,7 @@ namespace SharpCompress.Compressors.LZMA
                    }
                }

-                UInt32 startLen = 2; // speed optimization 
+                UInt32 startLen = 2; // speed optimization

                for (UInt32 repIndex = 0; repIndex < Base.K_NUM_REP_DISTANCES; repIndex++)
                {
@@ -1571,12 +1571,17 @@ namespace SharpCompress.Compressors.LZMA

        public void WriteCoderProperties(Stream outStream)
        {
-            _properties[0] = (Byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);
+            WriteCoderProperties(_properties);
+            outStream.Write(_properties, 0, K_PROP_SIZE);
+        }
+
+        public void WriteCoderProperties(Span<byte> span)
+        {
+            span[0] = (byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);
            for (int i = 0; i < 4; i++)
            {
-                _properties[1 + i] = (Byte)((_dictionarySize >> (8 * i)) & 0xFF);
+                span[1 + i] = (byte)((_dictionarySize >> (8 * i)) & 0xFF);
            }
-            outStream.Write(_properties, 0, K_PROP_SIZE);
        }

        private readonly UInt32[] _tempPrices = new UInt32[Base.K_NUM_FULL_DISTANCES];
@@ -1794,4 +1799,4 @@ namespace SharpCompress.Compressors.LZMA
            _trainSize = trainSize;
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/LZMA/LzmaStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/LzmaStream.cs
@@ -1,7 +1,7 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
 using SharpCompress.Compressors.LZMA.LZ;
-using SharpCompress.Converters;

 namespace SharpCompress.Compressors.LZMA
 {
@@ -56,7 +56,7 @@ namespace SharpCompress.Compressors.LZMA

            if (!isLzma2)
            {
-                _dictionarySize = DataConverter.LittleEndian.GetInt32(properties, 1);
+                _dictionarySize = BinaryPrimitives.ReadInt32LittleEndian(properties.AsSpan(1));
                _outWindow.Create(_dictionarySize);
                if (presetDictionary != null)
                {
@@ -107,9 +107,9 @@ namespace SharpCompress.Compressors.LZMA

            _encoder = new Encoder();
            _encoder.SetCoderProperties(properties._propIDs, properties._properties);
-            MemoryStream propStream = new MemoryStream(5);
-            _encoder.WriteCoderProperties(propStream);
-            Properties = propStream.ToArray();
+            byte[] prop = new byte[5];
+            _encoder.WriteCoderProperties(prop);
+            Properties = prop;

            _encoder.SetStreams(null, outputStream, -1, -1);
            if (presetDictionary != null)
@@ -315,4 +315,4 @@ namespace SharpCompress.Compressors.LZMA

        public byte[] Properties { get; } = new byte[5];
    }
-}
+}
--- a/src/SharpCompress/Compressors/PPMd/H/FreqData.cs
+++ b/src/SharpCompress/Compressors/PPMd/H/FreqData.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Buffers.Binary;
 using System.Text;
-using SharpCompress.Converters;

 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -19,7 +19,11 @@ namespace SharpCompress.Compressors.PPMd.H
        {
        }

-        internal int SummFreq { get => DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff; set => DataConverter.LittleEndian.PutBytes(Memory, Address, (short)value); }
+        internal int SummFreq
+        {
+            get => BinaryPrimitives.ReadInt16LittleEndian(Memory.AsSpan(Address)) & 0xffff;
+            set => BinaryPrimitives.WriteInt16LittleEndian(Memory.AsSpan(Address), (short)value);
+        }

        internal FreqData Initialize(byte[] mem)
        {
@@ -28,14 +32,12 @@ namespace SharpCompress.Compressors.PPMd.H

        internal void IncrementSummFreq(int dSummFreq)
        {
-            short summFreq = DataConverter.LittleEndian.GetInt16(Memory, Address);
-            summFreq += (short)dSummFreq;
-            DataConverter.LittleEndian.PutBytes(Memory, Address, summFreq);
+            SummFreq += (short)dSummFreq;
        }

        internal int GetStats()
        {
-            return DataConverter.LittleEndian.GetInt32(Memory, Address + 2);
+            return BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 2));
        }

        internal virtual void SetStats(State state)
@@ -45,7 +47,7 @@ namespace SharpCompress.Compressors.PPMd.H

        internal void SetStats(int state)
        {
-            DataConverter.LittleEndian.PutBytes(Memory, Address + 2, state);
+            BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 2), state);
        }

        public override String ToString()
@@ -64,4 +66,4 @@ namespace SharpCompress.Compressors.PPMd.H
            return buffer.ToString();
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/PPMd/H/PPMContext.cs
+++ b/src/SharpCompress/Compressors/PPMd/H/PPMContext.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Buffers.Binary;
 using System.Text;
-using SharpCompress.Converters;

 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -22,7 +22,7 @@ namespace SharpCompress.Compressors.PPMd.H
            {
                if (Memory != null)
                {
-                    _numStats = DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff;
+                    _numStats = BinaryPrimitives.ReadInt16LittleEndian(Memory.AsSpan(Address)) & 0xffff;
                }
                return _numStats;
            }
@@ -32,7 +32,7 @@ namespace SharpCompress.Compressors.PPMd.H
                _numStats = value & 0xffff;
                if (Memory != null)
                {
-                    DataConverter.LittleEndian.PutBytes(Memory, Address, (short)value);
+                    BinaryPrimitives.WriteInt16LittleEndian(Memory.AsSpan(Address), (short)value);
                }
            }
        }
@@ -109,7 +109,7 @@ namespace SharpCompress.Compressors.PPMd.H
        {
            if (Memory != null)
            {
-                _suffix = DataConverter.LittleEndian.GetInt32(Memory, Address + 8);
+                _suffix = BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 8));
            }
            return _suffix;
        }
@@ -124,7 +124,7 @@ namespace SharpCompress.Compressors.PPMd.H
            _suffix = suffix;
            if (Memory != null)
            {
-                DataConverter.LittleEndian.PutBytes(Memory, Address + 8, suffix);
+                BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 8), suffix);
            }
        }

@@ -307,7 +307,7 @@ namespace SharpCompress.Compressors.PPMd.H
        //		byte[] bytes = model.getSubAlloc().getHeap();
        //		int p1 = state1.Address;
        //		int p2 = state2.Address;
-        //		
+        //
        //		for (int i = 0; i < StatePtr.size; i++) {
        //			byte temp = bytes[p1+i];
        //			bytes[p1+i] = bytes[p2+i];
@@ -564,4 +564,4 @@ namespace SharpCompress.Compressors.PPMd.H
            UNION_SIZE = Math.Max(FreqData.SIZE, State.SIZE);
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/PPMd/H/RarMemBlock.cs
+++ b/src/SharpCompress/Compressors/PPMd/H/RarMemBlock.cs
@@ -1,4 +1,5 @@
-using SharpCompress.Converters;
+using System;
+using System.Buffers.Binary;

 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -21,7 +22,7 @@ namespace SharpCompress.Compressors.PPMd.H
            {
                if (Memory != null)
                {
-                    _stamp = DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff;
+                    _stamp = BinaryPrimitives.ReadInt16LittleEndian(Memory.AsSpan(Address)) & 0xffff;
                }
                return _stamp;
            }
@@ -31,7 +32,7 @@ namespace SharpCompress.Compressors.PPMd.H
                _stamp = value;
                if (Memory != null)
                {
-                    DataConverter.LittleEndian.PutBytes(Memory, Address, (short)value);
+                    BinaryPrimitives.WriteInt16LittleEndian(Memory.AsSpan(Address), (short)value);
                }
            }
        }
@@ -63,7 +64,7 @@ namespace SharpCompress.Compressors.PPMd.H
        {
            if (Memory != null)
            {
-                _next = DataConverter.LittleEndian.GetInt32(Memory, Address + 4);
+                _next = BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 4));
            }
            return _next;
        }
@@ -78,7 +79,7 @@ namespace SharpCompress.Compressors.PPMd.H
            _next = next;
            if (Memory != null)
            {
-                DataConverter.LittleEndian.PutBytes(Memory, Address + 4, next);
+                BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 4), next);
            }
        }

@@ -86,7 +87,7 @@ namespace SharpCompress.Compressors.PPMd.H
        {
            if (Memory != null)
            {
-                _nu = DataConverter.LittleEndian.GetInt16(Memory, Address + 2) & 0xffff;
+                _nu = BinaryPrimitives.ReadInt16LittleEndian(Memory.AsSpan(Address + 2)) & 0xffff;
            }
            return _nu;
        }
@@ -96,7 +97,7 @@ namespace SharpCompress.Compressors.PPMd.H
            _nu = nu & 0xffff;
            if (Memory != null)
            {
-                DataConverter.LittleEndian.PutBytes(Memory, Address + 2, (short)nu);
+                BinaryPrimitives.WriteInt16LittleEndian(Memory.AsSpan(Address + 2), (short)nu);
            }
        }

@@ -104,7 +105,7 @@ namespace SharpCompress.Compressors.PPMd.H
        {
            if (Memory != null)
            {
-                _prev = DataConverter.LittleEndian.GetInt32(Memory, Address + 8);
+                _prev = BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 8));
            }
            return _prev;
        }
@@ -119,8 +120,8 @@ namespace SharpCompress.Compressors.PPMd.H
            _prev = prev;
            if (Memory != null)
            {
-                DataConverter.LittleEndian.PutBytes(Memory, Address + 8, prev);
+                BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 8), prev);
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/PPMd/H/RarNode.cs
+++ b/src/SharpCompress/Compressors/PPMd/H/RarNode.cs
@@ -1,5 +1,6 @@
+using System;
+using System.Buffers.Binary;
 using System.Text;
-using SharpCompress.Converters;

 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -18,7 +19,7 @@ namespace SharpCompress.Compressors.PPMd.H
        {
            if (Memory != null)
            {
-                _next = DataConverter.LittleEndian.GetInt32(Memory, Address);
+                _next = BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address));
            }
            return _next;
        }
@@ -33,7 +34,7 @@ namespace SharpCompress.Compressors.PPMd.H
            _next = next;
            if (Memory != null)
            {
-                DataConverter.LittleEndian.PutBytes(Memory, Address, next);
+                BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address), next);
            }
        }

@@ -51,4 +52,4 @@ namespace SharpCompress.Compressors.PPMd.H
            return buffer.ToString();
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/PPMd/H/State.cs
+++ b/src/SharpCompress/Compressors/PPMd/H/State.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Buffers.Binary;
 using System.Text;
-using SharpCompress.Converters;

 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -29,7 +29,7 @@ namespace SharpCompress.Compressors.PPMd.H

        internal int GetSuccessor()
        {
-            return DataConverter.LittleEndian.GetInt32(Memory, Address + 2);
+            return BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 2));
        }

        internal void SetSuccessor(PpmContext successor)
@@ -39,7 +39,7 @@ namespace SharpCompress.Compressors.PPMd.H

        internal void SetSuccessor(int successor)
        {
-            DataConverter.LittleEndian.PutBytes(Memory, Address + 2, successor);
+            BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 2), successor);
        }

        internal void SetValues(StateRef state)
@@ -95,4 +95,4 @@ namespace SharpCompress.Compressors.PPMd.H
            return buffer.ToString();
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/PPMd/PpmdProperties.cs
+++ b/src/SharpCompress/Compressors/PPMd/PpmdProperties.cs
@@ -1,5 +1,6 @@
-using SharpCompress.Compressors.PPMd.I1;
-using SharpCompress.Converters;
+using System;
+using System.Buffers.Binary;
+using SharpCompress.Compressors.PPMd.I1;

 namespace SharpCompress.Compressors.PPMd
 {
@@ -25,7 +26,7 @@ namespace SharpCompress.Compressors.PPMd
            ModelOrder = modelOrder;
            RestorationMethod = modelRestorationMethod;
        }
-        
+
        public int ModelOrder { get; }
        public PpmdVersion Version { get; } = PpmdVersion.I1;
        internal ModelRestorationMethod RestorationMethod { get; }
@@ -34,7 +35,7 @@ namespace SharpCompress.Compressors.PPMd
        {
            if (properties.Length == 2)
            {
-                ushort props = DataConverter.LittleEndian.GetUInt16(properties, 0);
+                ushort props = BinaryPrimitives.ReadUInt16LittleEndian(properties);
                AllocatorSize = (((props >> 4) & 0xff) + 1) << 20;
                ModelOrder = (props & 0x0f) + 1;
                RestorationMethod = (ModelRestorationMethod)(props >> 12);
@@ -42,7 +43,7 @@ namespace SharpCompress.Compressors.PPMd
            else if (properties.Length == 5)
            {
                Version = PpmdVersion.H7Z;
-                AllocatorSize = DataConverter.LittleEndian.GetInt32(properties, 1);
+                AllocatorSize = BinaryPrimitives.ReadInt32LittleEndian(properties.AsSpan(1));
                ModelOrder = properties[0];
            }
        }
@@ -64,8 +65,16 @@ namespace SharpCompress.Compressors.PPMd
            }
        }

-        public byte[] Properties => DataConverter.LittleEndian.GetBytes(
-                                                                        (ushort)
-                                                                        ((ModelOrder - 1) + (((AllocatorSize >> 20) - 1) << 4) + ((ushort)RestorationMethod << 12)));
+        public byte[] Properties
+        {
+            get
+            {
+                byte[] bytes = new byte[2];
+                BinaryPrimitives.WriteUInt16LittleEndian(
+                    bytes,
+                    (ushort)((ModelOrder - 1) + (((AllocatorSize >> 20) - 1) << 4) + ((ushort)RestorationMethod << 12)));
+                return bytes;
+            }
+        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack15_cpp.cs
+++ b/src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack15_cpp.cs
@@ -1,4 +1,5 @@
-using static SharpCompress.Compressors.Rar.UnpackV2017.Unpack.Unpack15Local;
+using System;
+using static SharpCompress.Compressors.Rar.UnpackV2017.Unpack.Unpack15Local;

 namespace SharpCompress.Compressors.Rar.UnpackV2017
 {
@@ -461,9 +462,9 @@ internal static class Unpack15Local {
    ChSetA[I]=(ushort)I;
    ChSetC[I]=(ushort)(((~I+1) & 0xff)<<8);
  }
-  Utility.Memset(NToPl,0,NToPl.Length);
-  Utility.Memset(NToPlB,0,NToPlB.Length);
-  Utility.Memset(NToPlC,0,NToPlC.Length);
+  new Span<byte>(NToPl).Fill(0);
+  new Span<byte>(NToPlB).Fill(0);
+  new Span<byte>(NToPlC).Fill(0);
  CorrHuff(ChSetB,NToPlB);
 }

@@ -473,7 +474,7 @@ internal static class Unpack15Local {
  for (I=7;I>=0;I--)
    for (J=0;J<32;J++)
      CharSet[J]=(ushort)((CharSet[J] & ~0xff) | I);
-  Utility.Memset(NumToPlace,0,NToPl.Length);
+  new Span<byte>(NumToPlace, 0, NToPl.Length).Fill(0);
  for (I=6;I>=0;I--)
    NumToPlace[I]=(byte)((7-I)*32);
 }
--- a/src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack20_cpp.cs
+++ b/src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack20_cpp.cs
@@ -191,7 +191,7 @@ internal static class Unpack20Local {
  UnpAudioBlock=(BitField & 0x8000)!=0;

  if ((BitField & 0x4000) != 0)
-    Utility.Memset(UnpOldTable20,0,UnpOldTable20.Length);
+    new Span<byte>(UnpOldTable20).Fill(0);
  Inp.addbits(2);

  uint TableSize;
@@ -296,7 +296,7 @@ internal static class Unpack20Local {

    //memset(AudV,0,sizeof(AudV));
    AudV = new AudioVariables[4];
-    Utility.Memset(UnpOldTable20, 0, UnpOldTable20.Length);
+    new Span<byte>(UnpOldTable20).Fill(0);
    //memset(MD,0,sizeof(MD));
    MD = new DecodeTable[4];
  }
--- a/src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack_cpp.cs
+++ b/src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack_cpp.cs
@@ -196,7 +196,7 @@ public Unpack(/* ComprDataIO *DataIO */)
 {
  if (!Solid)
  {
-    Utility.Memset<uint>(OldDist, 0, OldDist.Length);
+    new Span<uint>(OldDist).Fill(0);
    OldDistPtr=0;
    LastDist=LastLength=0;
 //    memset(Window,0,MaxWinSize);
--- a/src/SharpCompress/Compressors/Rar/VM/RarVM.cs
+++ b/src/SharpCompress/Compressors/Rar/VM/RarVM.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
-using SharpCompress.Converters;

 namespace SharpCompress.Compressors.Rar.VM
 {
@@ -72,9 +72,9 @@ namespace SharpCompress.Compressors.Rar.VM
            }
            if (IsVMMem(mem))
            {
-                return DataConverter.LittleEndian.GetInt32(mem, offset);
+                return BinaryPrimitives.ReadInt32LittleEndian(mem.AsSpan(offset));
            }
-            return DataConverter.BigEndian.GetInt32(mem, offset);
+            return BinaryPrimitives.ReadInt32BigEndian(mem.AsSpan(offset));
        }

        private void SetValue(bool byteMode, byte[] mem, int offset, int value)
@@ -94,11 +94,11 @@ namespace SharpCompress.Compressors.Rar.VM
            {
                if (IsVMMem(mem))
                {
-                    DataConverter.LittleEndian.PutBytes(mem, offset, value);
+                    BinaryPrimitives.WriteInt32LittleEndian(mem.AsSpan(offset), value);
                }
                else
                {
-                    DataConverter.BigEndian.PutBytes(mem, offset, value);
+                    BinaryPrimitives.WriteInt32BigEndian(mem.AsSpan(offset), value);
                }
            }

@@ -120,12 +120,12 @@ namespace SharpCompress.Compressors.Rar.VM
            if (cmdOp.Type == VMOpType.VM_OPREGMEM)
            {
                int pos = (cmdOp.Offset + cmdOp.Base) & VM_MEMMASK;
-                ret = DataConverter.LittleEndian.GetInt32(Mem, pos);
+                ret = BinaryPrimitives.ReadInt32LittleEndian(Mem.AsSpan(pos));
            }
            else
            {
                int pos = cmdOp.Offset;
-                ret = DataConverter.LittleEndian.GetInt32(Mem, pos);
+                ret = BinaryPrimitives.ReadInt32LittleEndian(Mem.AsSpan(pos));
            }
            return ret;
        }
--- a/src/SharpCompress/Converters/DataConverter.cs
+++ b/src/SharpCompress/Converters/DataConverter.cs
--- a/src/SharpCompress/IO/MarkingBinaryReader.cs
+++ b/src/SharpCompress/IO/MarkingBinaryReader.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
-using SharpCompress.Converters;

 namespace SharpCompress.IO
 {
@@ -81,17 +81,17 @@ namespace SharpCompress.IO

        public override short ReadInt16()
        {
-            return DataConverter.LittleEndian.GetInt16(ReadBytes(2), 0);
+            return BinaryPrimitives.ReadInt16LittleEndian(ReadBytes(2));
        }

        public override int ReadInt32()
        {
-            return DataConverter.LittleEndian.GetInt32(ReadBytes(4), 0);
+            return BinaryPrimitives.ReadInt32LittleEndian(ReadBytes(4));
        }

        public override long ReadInt64()
        {
-            return DataConverter.LittleEndian.GetInt64(ReadBytes(8), 0);
+            return BinaryPrimitives.ReadInt64LittleEndian(ReadBytes(8));
        }

        public override sbyte ReadSByte()
@@ -111,17 +111,17 @@ namespace SharpCompress.IO

        public override ushort ReadUInt16()
        {
-            return DataConverter.LittleEndian.GetUInt16(ReadBytes(2), 0);
+            return BinaryPrimitives.ReadUInt16LittleEndian(ReadBytes(2));
        }

        public override uint ReadUInt32()
        {
-            return DataConverter.LittleEndian.GetUInt32(ReadBytes(4), 0);
+            return BinaryPrimitives.ReadUInt32LittleEndian(ReadBytes(4));
        }

        public override ulong ReadUInt64()
        {
-            return DataConverter.LittleEndian.GetUInt64(ReadBytes(8), 0);
+            return BinaryPrimitives.ReadUInt64LittleEndian(ReadBytes(8));
        }

        // RAR5 style variable length encoded value
@@ -196,4 +196,4 @@ namespace SharpCompress.IO
            throw new FormatException("malformed vint");
        }
    }
-}
+}
--- a/src/SharpCompress/SharpCompress.csproj
+++ b/src/SharpCompress/SharpCompress.csproj
@@ -2,14 +2,14 @@
  <PropertyGroup>
    <AssemblyTitle>SharpCompress - Pure C# Decompression/Compression</AssemblyTitle>
    <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>0.24.0</VersionPrefix>
-    <AssemblyVersion>0.24.0</AssemblyVersion>
-    <FileVersion>0.24.0</FileVersion>
+    <VersionPrefix>0.25.0</VersionPrefix>
+    <AssemblyVersion>0.25.0</AssemblyVersion>
+    <FileVersion>0.25.0</FileVersion>
    <Authors>Adam Hathcock</Authors>
    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">netstandard1.3;netstandard2.0;netstandard2.1;net46</TargetFrameworks>
    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
    <AssemblyName>SharpCompress</AssemblyName>
    <AssemblyOriginatorKeyFile>../../SharpCompress.snk</AssemblyOriginatorKeyFile>
    <SignAssembly>true</SignAssembly>
@@ -21,10 +21,14 @@
    <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
    <Description>SharpCompress is a compression library for NET Standard 1.3/2.0 that can unrar, decompress 7zip, decompress xz, zip/unzip, tar/untar lzip/unlzip, bzip2/unbzip2 and gzip/ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip is implemented.</Description>
+    <LangVersion>latest</LangVersion>
  </PropertyGroup>
+
  <ItemGroup>
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.7.0" />
    <PackageReference Include="System.Text.Encoding.CodePages" Version="4.7.0" />
-    <PackageReference Include="System.Memory" Version="4.5.3" />
+  </ItemGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' != 'netstandard2.1' ">
+    <PackageReference Include="System.Memory" Version="4.5.4" />
  </ItemGroup>
 </Project>
--- a/src/SharpCompress/Utility.cs
+++ b/src/SharpCompress/Utility.cs
@@ -43,12 +43,6 @@ namespace SharpCompress
            return (number >> bits) + (2L << ~bits);
        }

-        public static void Memset(byte[] array, byte what, int length)
-            => new Span<byte>(array, 0, length).Fill(what);
-
-        public static void Memset<T>(T[] array, T what, int length)
-            => new Span<T>(array, 0, length).Fill(what);
-
        public static void SetSize(this List<byte> list, int count)
        {
            if (count > list.Count)
--- a/src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs
+++ b/src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs
@@ -1,10 +1,10 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
 using System.Text;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
-using SharpCompress.Converters;

 namespace SharpCompress.Writers.Zip
 {
@@ -67,39 +67,60 @@ namespace SharpCompress.Writers.Zip
            if (Decompressed == 0 && Compressed == 0)
                usedCompression = ZipCompressionMethod.None;

+            byte[] intBuf = new byte[] { 80, 75, 1, 2, version, 0, version, 0 };
            //constant sig, then version made by, then version to extract
-            outputStream.Write(new byte[] { 80, 75, 1, 2, version, 0, version, 0 }, 0, 8);
+            outputStream.Write(intBuf, 0, 8);

-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)flags), 0, 2);
-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)usedCompression), 0, 2); // zipping method
-            outputStream.Write(DataConverter.LittleEndian.GetBytes(ModificationTime.DateTimeToDosTime()), 0, 4);
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
+            outputStream.Write(intBuf, 0, 2);
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)usedCompression);
+            outputStream.Write(intBuf, 0, 2); // zipping method
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ModificationTime.DateTimeToDosTime());
+            outputStream.Write(intBuf, 0, 4);

            // zipping date and time
-            outputStream.Write(DataConverter.LittleEndian.GetBytes(Crc), 0, 4); // file CRC
-            outputStream.Write(DataConverter.LittleEndian.GetBytes(compressedvalue), 0, 4); // compressed file size
-            outputStream.Write(DataConverter.LittleEndian.GetBytes(decompressedvalue), 0, 4); // uncompressed file size
-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedFilename.Length), 0, 2); // Filename in zip
-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)extralength), 0, 2); // extra length
-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedComment.Length), 0, 2);
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, Crc);
+            outputStream.Write(intBuf, 0, 4); // file CRC
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, compressedvalue);
+            outputStream.Write(intBuf, 0, 4); // compressed file size
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, decompressedvalue);
+            outputStream.Write(intBuf, 0, 4); // uncompressed file size
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedFilename.Length);
+            outputStream.Write(intBuf, 0, 2); // Filename in zip
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)extralength);
+            outputStream.Write(intBuf, 0, 2); // extra length
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedComment.Length);
+            outputStream.Write(intBuf, 0, 2);

-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0), 0, 2); // disk=0
-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0), 0, 2); // file type: binary
-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0), 0, 2); // Internal file attributes
-            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x8100), 0, 2);
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0);
+            outputStream.Write(intBuf, 0, 2); // disk=0
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
+            outputStream.Write(intBuf, 0, 2); // file type: binary
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
+            outputStream.Write(intBuf, 0, 2); // Internal file attributes
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x8100);
+            outputStream.Write(intBuf, 0, 2);

            // External file attributes (normal/readable)
-            outputStream.Write(DataConverter.LittleEndian.GetBytes(headeroffsetvalue), 0, 4); // Offset of header
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, headeroffsetvalue);
+            outputStream.Write(intBuf, 0, 4); // Offset of header

            outputStream.Write(encodedFilename, 0, encodedFilename.Length);
            if (zip64)
            {
-                outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x0001), 0, 2);
-                outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)(extralength - 4)), 0, 2);
+                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x0001);
+                outputStream.Write(intBuf, 0, 2);
+                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)(extralength - 4));
+                outputStream.Write(intBuf, 0, 2);

-                outputStream.Write(DataConverter.LittleEndian.GetBytes(Decompressed), 0, 8);
-                outputStream.Write(DataConverter.LittleEndian.GetBytes(Compressed), 0, 8);
-                outputStream.Write(DataConverter.LittleEndian.GetBytes(HeaderOffset), 0, 8);
-                outputStream.Write(DataConverter.LittleEndian.GetBytes(0), 0, 4); // VolumeNumber = 0
+                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, Decompressed);
+                outputStream.Write(intBuf, 0, 8);
+                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, Compressed);
+                outputStream.Write(intBuf, 0, 8);
+                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, HeaderOffset);
+                outputStream.Write(intBuf, 0, 8);
+                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
+                outputStream.Write(intBuf, 0, 4); // VolumeNumber = 0
            }

            outputStream.Write(encodedComment, 0, encodedComment.Length);
@@ -108,4 +129,4 @@ namespace SharpCompress.Writers.Zip
                                    + 2 + 2 + 2 + 2 + 4 + encodedFilename.Length + extralength + encodedComment.Length);
        }
    }
-}
+}
--- a/src/SharpCompress/Writers/Zip/ZipWriter.cs
+++ b/src/SharpCompress/Writers/Zip/ZipWriter.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
@@ -10,7 +11,6 @@ using SharpCompress.Compressors.BZip2;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.Compressors.LZMA;
 using SharpCompress.Compressors.PPMd;
-using SharpCompress.Converters;
 using SharpCompress.IO;

 namespace SharpCompress.Writers.Zip
@@ -37,7 +37,7 @@ namespace SharpCompress.Writers.Zip

            compressionType = zipWriterOptions.CompressionType;
            compressionLevel = zipWriterOptions.DeflateCompressionLevel;
-            
+
            if (WriterOptions.LeaveStreamOpen)
            {
                destination = new NonDisposingStream(destination);
@@ -162,7 +162,10 @@ namespace SharpCompress.Writers.Zip
            var explicitZipCompressionInfo = ToZipCompressionMethod(zipWriterEntryOptions.CompressionType ?? compressionType);
            byte[] encodedFilename = WriterOptions.ArchiveEncoding.Encode(filename);

-            OutputStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4);
+            // TODO: Use stackalloc when we exclusively support netstandard2.1 or higher
+            byte[] intBuf = new byte[4];
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ZipHeaderFactory.ENTRY_HEADER_BYTES);
+            OutputStream.Write(intBuf, 0, 4);
            if (explicitZipCompressionInfo == ZipCompressionMethod.Deflate)
            {
                if (OutputStream.CanSeek && useZip64)
@@ -184,21 +187,27 @@ namespace SharpCompress.Writers.Zip
                    flags |= HeaderFlags.Bit1; // eos marker
                }
            }
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)flags), 0, 2);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)explicitZipCompressionInfo), 0, 2); // zipping method
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes(zipWriterEntryOptions.ModificationDateTime.DateTimeToDosTime()), 0, 4);
+
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
+            OutputStream.Write(intBuf, 0, 2);
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)explicitZipCompressionInfo);
+            OutputStream.Write(intBuf, 0, 2); // zipping method
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, zipWriterEntryOptions.ModificationDateTime.DateTimeToDosTime());
+            OutputStream.Write(intBuf, 0, 4);

            // zipping date and time
            OutputStream.Write(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 0, 12);

            // unused CRC, un/compressed size, updated later
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedFilename.Length), 0, 2); // filename length
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedFilename.Length);
+            OutputStream.Write(intBuf, 0, 2); // filename length

            var extralength = 0;
            if (OutputStream.CanSeek && useZip64)
                extralength = 2 + 2 + 8 + 8;

-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)extralength), 0, 2); // extra length
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)extralength);
+            OutputStream.Write(intBuf, 0, 2); // extra length
            OutputStream.Write(encodedFilename, 0, encodedFilename.Length);

            if (extralength != 0)
@@ -212,44 +221,60 @@ namespace SharpCompress.Writers.Zip

        private void WriteFooter(uint crc, uint compressed, uint uncompressed)
        {
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes(crc), 0, 4);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes(compressed), 0, 4);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes(uncompressed), 0, 4);
+            byte[] intBuf = new byte[4];
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, crc);
+            OutputStream.Write(intBuf, 0, 4);
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, compressed);
+            OutputStream.Write(intBuf, 0, 4);
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, uncompressed);
+            OutputStream.Write(intBuf, 0, 4);
        }

        private void WriteEndRecord(ulong size)
        {
-            byte[] encodedComment = WriterOptions.ArchiveEncoding.Encode(zipComment);
+
            var zip64 = isZip64 || 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;

+            byte[] intBuf = new byte[8];
            if (zip64)
            {
                var recordlen = 2 + 2 + 4 + 4 + 8 + 8 + 8 + 8;

                // Write zip64 end of central directory record
                OutputStream.Write(new byte[] { 80, 75, 6, 6 }, 0, 4);
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)recordlen), 0, 8); // Size of zip64 end of central directory record
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0), 0, 2); // Made by
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)45), 0, 2); // Version needed

-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint)0), 0, 4); // Disk number
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint)0), 0, 4); // Central dir disk
+                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)recordlen);
+                OutputStream.Write(intBuf, 0, 8); // Size of zip64 end of central directory record
+                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0);
+                OutputStream.Write(intBuf, 0, 2); // Made by
+                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 45);
+                OutputStream.Write(intBuf, 0, 2); // Version needed
+
+                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
+                OutputStream.Write(intBuf, 0, 4); // Disk number
+                OutputStream.Write(intBuf, 0, 4); // Central dir disk

                // TODO: entries.Count is int, so max 2^31 files
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)entries.Count), 0, 8); // Entries in this disk
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)entries.Count), 0, 8); // Total entries
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes(size), 0, 8); // Central Directory size
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)streamPosition), 0, 8); // Disk offset
+                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)entries.Count);
+                OutputStream.Write(intBuf, 0, 8); // Entries in this disk
+                OutputStream.Write(intBuf, 0, 8); // Total entries
+                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, size);
+                OutputStream.Write(intBuf, 0, 8); // Central Directory size
+                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)streamPosition);
+                OutputStream.Write(intBuf, 0, 8); // Disk offset

                // Write zip64 end of central directory locator
                OutputStream.Write(new byte[] { 80, 75, 6, 7 }, 0, 4);

-                OutputStream.Write(DataConverter.LittleEndian.GetBytes(0uL), 0, 4); // Entry disk
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)streamPosition + size), 0, 8); // Offset to the zip64 central directory
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes(0u), 0, 4); // Number of disks
+                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
+                OutputStream.Write(intBuf, 0, 4); // Entry disk
+                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)streamPosition + size);
+                OutputStream.Write(intBuf, 0, 8); // Offset to the zip64 central directory
+                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
+                OutputStream.Write(intBuf, 0, 4); // Number of disks

                streamPosition += recordlen + (4 + 4 + 8 + 4);
                streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streampositionvalue;
@@ -257,11 +282,16 @@ namespace SharpCompress.Writers.Zip

            // Write normal end of central directory record
            OutputStream.Write(new byte[] { 80, 75, 5, 6, 0, 0, 0, 0 }, 0, 8);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)entries.Count), 0, 2);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)entries.Count), 0, 2);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes(sizevalue), 0, 4);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint)streampositionvalue), 0, 4);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedComment.Length), 0, 2);
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)entries.Count);
+            OutputStream.Write(intBuf, 0, 2);
+            OutputStream.Write(intBuf, 0, 2);
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, sizevalue);
+            OutputStream.Write(intBuf, 0, 4);
+            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, streampositionvalue);
+            OutputStream.Write(intBuf, 0, 4);
+            byte[] encodedComment = WriterOptions.ArchiveEncoding.Encode(zipComment);
+            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedComment.Length);
+            OutputStream.Write(intBuf, 0, 2);
            OutputStream.Write(encodedComment, 0, encodedComment.Length);
        }

@@ -405,11 +435,16 @@ namespace SharpCompress.Writers.Zip
                        if (entry.Zip64HeaderOffset != 0)
                        {
                            originalStream.Position = (long)(entry.HeaderOffset + entry.Zip64HeaderOffset);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x0001), 0, 2);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)(8 + 8)), 0, 2);
+                            byte[] intBuf = new byte[8];
+                            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x0001);
+                            originalStream.Write(intBuf, 0, 2);
+                            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 8 + 8);
+                            originalStream.Write(intBuf, 0, 2);

-                            originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Decompressed), 0, 8);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Compressed), 0, 8);
+                            BinaryPrimitives.WriteUInt64LittleEndian(intBuf, entry.Decompressed);
+                            originalStream.Write(intBuf, 0, 8);
+                            BinaryPrimitives.WriteUInt64LittleEndian(intBuf, entry.Compressed);
+                            originalStream.Write(intBuf, 0, 8);
                        }

                        originalStream.Position = writer.streamPosition + (long)entry.Compressed;
@@ -426,10 +461,12 @@ namespace SharpCompress.Writers.Zip
                        if (zip64)
                            throw new NotSupportedException("Streams larger than 4GiB are not supported for non-seekable streams");

-                        originalStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.POST_DATA_DESCRIPTOR), 0, 4);
+                        byte[] intBuf = new byte[4];
+                        BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ZipHeaderFactory.POST_DATA_DESCRIPTOR);
+                        originalStream.Write(intBuf, 0, 4);
                        writer.WriteFooter(entry.Crc,
-                                           (uint)compressedvalue,
-                                           (uint)decompressedvalue);
+                                           compressedvalue,
+                                           decompressedvalue);
                        writer.streamPosition += (long)entry.Compressed + 16;
                    }
                    writer.entries.Add(entry);
@@ -489,4 +526,4 @@ namespace SharpCompress.Writers.Zip

        #endregion Nested type: ZipWritingStream
    }
-}
+}
--- a/tests/SharpCompress.Test/SharpCompress.Test.csproj
+++ b/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.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
    <PackageReference Include="xunit" Version="2.4.1" />
    <PackageReference Include="Xunit.SkippableFact" Version="1.3.12" />
--- a/tests/SharpCompress.Test/Zip/ZipReaderTests.cs
+++ b/tests/SharpCompress.Test/Zip/ZipReaderTests.cs
@@ -315,5 +315,30 @@ namespace SharpCompress.Test.Zip
                }
            }
        }
+
+        [Fact]
+        public void Zip_None_Issue86_Streamed_Read()
+        {
+            var keys = new string[] { "Empty1", "Empty2", "Dir1/", "Dir2/", "Fake1", "Fake2", "Internal.zip" };
+
+            using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.none.issue86.zip")))
+            using (var reader = ZipReader.Open(stream))
+            {
+                foreach( var key in keys )
+                {
+                    reader.MoveToNextEntry();
+
+                    Assert.Equal( reader.Entry.Key, key );
+
+                    if (!reader.Entry.IsDirectory)
+                    {
+                        Assert.Equal(CompressionType.None, reader.Entry.CompressionType);
+                    }
+                }
+
+                Assert.False(reader.MoveToNextEntry());
+            }
+        }
+
    }
 }
--- a/tests/TestArchives/Archives/Zip.none.issue86.zip
+++ b/tests/TestArchives/Archives/Zip.none.issue86.zip
Author	SHA1	Message	Date
Adam Hathcock	762497b1c1	Tag for 0.25.0 and update packages	2020-04-03 08:25:43 +01:00
Adam Hathcock	be9edc7512	Merge pull request #500 from Erior/Issue_86 ZipReader/StreamingZipReaderFactory fails for archive entries which are uncompressed files in ZIP format #86	2020-01-17 09:38:19 +00:00
Lars Vahlenberg	9bf9d34d94	Issue86 Proposal	2020-01-16 22:08:48 +01:00
Adam Hathcock	df8405006c	Fix workflow name	2020-01-03 09:24:08 +00:00
Adam Hathcock	d135fdce58	Give github actions build a name and use badge	2020-01-03 09:22:51 +00:00
Adam Hathcock	ba570b93bb	Merge pull request #496 from Bond-009/allocations Reduce the amount of allocations	2020-01-03 09:18:17 +00:00
Adam Hathcock	6dfe0c7a96	Merge branch 'master' into allocations	2020-01-03 09:16:46 +00:00
Adam Hathcock	73d4430a65	Merge pull request #498 from adamhathcock/build-netcore3 Build netcore3	2020-01-03 09:15:14 +00:00
Bond-009	d2c2b58f3b	Fix language version and add netstandard2.1	2020-01-02 17:43:58 +01:00
Bond_009	50d4b39ca0	Fix test	2019-12-30 22:17:45 +01:00
Bond_009	1ed675e960	Minor improvement	2019-12-30 19:19:05 +01:00
Bond_009	80b0671844	Reduce the amount of allocations * Directly fill an array instead of filling a List and copying that to an array * Use own buffer when writing bytes to a stream * Remove DataConverter class, replaced by BinaryPrimitives	2019-12-30 18:58:25 +01:00