some async implementations

src/SharpCompress/Compressors/LZMA/AesDecoderStream.cs

@@ -2,6 +2,8 @@ using System;
 using System.IO;
 using System.Security.Cryptography;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
 
@@ -283,5 +285,70 @@ internal sealed class AesDecoderStream : DecoderStream2, IStreamStack
         return count;
     }
 
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (count == 0 || mWritten == mLimit)
+        {
+            return 0;
+        }
+
+        if (mUnderflow > 0)
+        {
+            return HandleUnderflow(buffer, offset, count);
+        }
+
+        // Need at least 16 bytes to proceed.
+        if (mEnding - mOffset < 16)
+        {
+            Buffer.BlockCopy(mBuffer, mOffset, mBuffer, 0, mEnding - mOffset);
+            mEnding -= mOffset;
+            mOffset = 0;
+
+            do
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                var read = await mStream
+                    .ReadAsync(mBuffer, mEnding, mBuffer.Length - mEnding, cancellationToken)
+                    .ConfigureAwait(false);
+                if (read == 0)
+                {
+                    // We are not done decoding and have less than 16 bytes.
+                    throw new EndOfStreamException();
+                }
+
+                mEnding += read;
+            } while (mEnding - mOffset < 16);
+        }
+
+        // We shouldn't return more data than we are limited to.
+        if (count > mLimit - mWritten)
+        {
+            count = (int)(mLimit - mWritten);
+        }
+
+        // We cannot transform less than 16 bytes into the target buffer,
+        // but we also cannot return zero, so we need to handle this.
+        if (count < 16)
+        {
+            return HandleUnderflow(buffer, offset, count);
+        }
+
+        if (count > mEnding - mOffset)
+        {
+            count = mEnding - mOffset;
+        }
+
+        // Otherwise we transform directly into the target buffer.
+        var processed = mDecoder.TransformBlock(mBuffer, mOffset, count & ~15, buffer, offset);
+        mOffset += processed;
+        mWritten += processed;
+        return processed;
+    }
+
     #endregion
 }

src/SharpCompress/Compressors/LZMA/LzmaStream.cs

@@ -3,6 +3,8 @@
 using System;
 using System.Buffers.Binary;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.LZ;
 using SharpCompress.IO;
 
@@ -423,6 +425,82 @@ public class LzmaStream : Stream, IStreamStack
         }
     }
 
+    private async Task DecodeChunkHeaderAsync(CancellationToken cancellationToken = default)
+    {
+        var controlBuffer = new byte[1];
+        await _inputStream.ReadAsync(controlBuffer, 0, 1, cancellationToken).ConfigureAwait(false);
+        var control = controlBuffer[0];
+        _inputPosition++;
+
+        if (control == 0x00)
+        {
+            _endReached = true;
+            return;
+        }
+
+        if (control >= 0xE0 || control == 0x01)
+        {
+            _needProps = true;
+            _needDictReset = false;
+            _outWindow.Reset();
+        }
+        else if (_needDictReset)
+        {
+            throw new DataErrorException();
+        }
+
+        if (control >= 0x80)
+        {
+            _uncompressedChunk = false;
+
+            _availableBytes = (control & 0x1F) << 16;
+            var buffer = new byte[2];
+            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
+            _availableBytes += (buffer[0] << 8) + buffer[1] + 1;
+            _inputPosition += 2;
+
+            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
+            _rangeDecoderLimit = (buffer[0] << 8) + buffer[1] + 1;
+            _inputPosition += 2;
+
+            if (control >= 0xC0)
+            {
+                _needProps = false;
+                await _inputStream
+                    .ReadAsync(controlBuffer, 0, 1, cancellationToken)
+                    .ConfigureAwait(false);
+                Properties[0] = controlBuffer[0];
+                _inputPosition++;
+
+                _decoder = new Decoder();
+                _decoder.SetDecoderProperties(Properties);
+            }
+            else if (_needProps)
+            {
+                throw new DataErrorException();
+            }
+            else if (control >= 0xA0)
+            {
+                _decoder = new Decoder();
+                _decoder.SetDecoderProperties(Properties);
+            }
+
+            _rangeDecoder.Init(_inputStream);
+        }
+        else if (control > 0x02)
+        {
+            throw new DataErrorException();
+        }
+        else
+        {
+            _uncompressedChunk = true;
+            var buffer = new byte[2];
+            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
+            _availableBytes = (buffer[0] << 8) + buffer[1] + 1;
+            _inputPosition += 2;
+        }
+    }
+
     public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
 
     public override void SetLength(long value) => throw new NotSupportedException();
@@ -435,5 +513,112 @@ public class LzmaStream : Stream, IStreamStack
         }
     }
 
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_endReached)
+        {
+            return 0;
+        }
+
+        var total = 0;
+        while (total < count)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (_availableBytes == 0)
+            {
+                if (_isLzma2)
+                {
+                    await DecodeChunkHeaderAsync(cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    _endReached = true;
+                }
+                if (_endReached)
+                {
+                    break;
+                }
+            }
+
+            var toProcess = count - total;
+            if (toProcess > _availableBytes)
+            {
+                toProcess = (int)_availableBytes;
+            }
+
+            _outWindow.SetLimit(toProcess);
+            if (_uncompressedChunk)
+            {
+                _inputPosition += _outWindow.CopyStream(_inputStream, toProcess);
+            }
+            else if (_decoder.Code(_dictionarySize, _outWindow, _rangeDecoder) && _outputSize < 0)
+            {
+                _availableBytes = _outWindow.AvailableBytes;
+            }
+
+            var read = _outWindow.Read(buffer, offset, toProcess);
+            total += read;
+            offset += read;
+            _position += read;
+            _availableBytes -= read;
+
+            if (_availableBytes == 0 && !_uncompressedChunk)
+            {
+                if (
+                    !_rangeDecoder.IsFinished
+                    || (_rangeDecoderLimit >= 0 && _rangeDecoder._total != _rangeDecoderLimit)
+                )
+                {
+                    _outWindow.SetLimit(toProcess + 1);
+                    if (!_decoder.Code(_dictionarySize, _outWindow, _rangeDecoder))
+                    {
+                        _rangeDecoder.ReleaseStream();
+                        throw new DataErrorException();
+                    }
+                }
+
+                _rangeDecoder.ReleaseStream();
+
+                _inputPosition += _rangeDecoder._total;
+                if (_outWindow.HasPending)
+                {
+                    throw new DataErrorException();
+                }
+            }
+        }
+
+        if (_endReached)
+        {
+            if (_inputSize >= 0 && _inputPosition != _inputSize)
+            {
+                throw new DataErrorException();
+            }
+            if (_outputSize >= 0 && _position != _outputSize)
+            {
+                throw new DataErrorException();
+            }
+        }
+
+        return total;
+    }
+
+    public override async Task WriteAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        Write(buffer, offset, count);
+        await Task.CompletedTask;
+    }
+
     public byte[] Properties { get; } = new byte[5];
 }

src/SharpCompress/Compressors/LZMA/Utilites/CrcBuilderStream.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.LZMA.Utilites;
@@ -101,4 +103,22 @@ internal class CrcBuilderStream : Stream, IStreamStack
         _mCrc = Crc.Update(_mCrc, buffer, offset, count);
         _mTarget.Write(buffer, offset, count);
     }
+
+    public override async Task WriteAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (_mFinished)
+        {
+            throw new InvalidOperationException("CRC calculation has been finished.");
+        }
+
+        Processed += count;
+        _mCrc = Crc.Update(_mCrc, buffer, offset, count);
+        await _mTarget.WriteAsync(buffer, offset, count, cancellationToken);
+    }
 }