diff --git a/src/SharpCompress/IO/DataDescriptorStream.cs b/src/SharpCompress/IO/DataDescriptorStream.cs
index fb93153c..34957678 100644
--- a/src/SharpCompress/IO/DataDescriptorStream.cs
+++ b/src/SharpCompress/IO/DataDescriptorStream.cs
@@ -40,7 +40,7 @@ public class DataDescriptorStream : Stream, IStreamStack
 
     public override bool CanRead => true;
 
-    public override bool CanSeek => _stream.CanSeek;
+    public override bool CanSeek => false;
 
     public override bool CanWrite => false;
 
diff --git a/tests/SharpCompress.Test/ReaderFactoryTests.cs b/tests/SharpCompress.Test/ReaderFactoryTests.cs
index aaa9ad97..119b041c 100644
--- a/tests/SharpCompress.Test/ReaderFactoryTests.cs
+++ b/tests/SharpCompress.Test/ReaderFactoryTests.cs
@@ -72,6 +72,32 @@ public class ReaderFactoryTests : TestBase
         );
     }
 
+    [Fact]
+    public async ValueTask OpenAsyncReader_DeflateStream_WithTarPayload_DetectsTarReader()
+    {
+        using var compressedStream = new MemoryStream(CompressWithDeflate(CreateTarPayload()));
+        using var sharpCompressStream = SharpCompress.IO.SharpCompressStream.CreateNonDisposing(
+            compressedStream
+        );
+        using var deflateStream = new DeflateStream(
+            sharpCompressStream,
+            CompressionMode.Decompress,
+            CompressionLevel.Default,
+            leaveOpen: false
+        );
+        await using var reader = await ReaderFactory.OpenAsyncReader(deflateStream);
+
+        Assert.IsType<TarReader>(reader);
+        Assert.Equal(
+            new Dictionary<string, string>
+            {
+                ["alpha.txt"] = "alpha",
+                ["nested/beta.txt"] = "beta",
+            },
+            await ReadAllFilesAsync(reader)
+        );
+    }
+
     private static Dictionary<string, string> ReadAllFiles(IReader reader)
     {
         var entries = new Dictionary<string, string>();
@@ -90,6 +116,26 @@ public class ReaderFactoryTests : TestBase
         return entries;
     }
 
+    private static async ValueTask<Dictionary<string, string>> ReadAllFilesAsync(
+        IAsyncReader reader
+    )
+    {
+        var entries = new Dictionary<string, string>();
+        while (await reader.MoveToNextEntryAsync())
+        {
+            if (reader.Entry.IsDirectory)
+            {
+                continue;
+            }
+
+            using var entryStream = await reader.OpenEntryStreamAsync();
+            using var streamReader = new StreamReader(entryStream, Encoding.UTF8);
+            entries.Add(reader.Entry.Key!, await streamReader.ReadToEndAsync());
+        }
+
+        return entries;
+    }
+
     private static byte[] CreateTarPayload()
     {
         var archiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8 };
diff --git a/tests/SharpCompress.Test/Streams/SharpCompressStreamFactoryTest.cs b/tests/SharpCompress.Test/Streams/SharpCompressStreamFactoryTest.cs
index c94db650..e3e709e3 100644
--- a/tests/SharpCompress.Test/Streams/SharpCompressStreamFactoryTest.cs
+++ b/tests/SharpCompress.Test/Streams/SharpCompressStreamFactoryTest.cs
@@ -138,6 +138,25 @@ public class SharpCompressStreamFactoryTest
         Assert.Same(wrappedStream, result.BaseStream());
     }
 
+    [Fact]
+    public void Create_WithDataDescriptorStream_UsesBufferedWrapper()
+    {
+        using var ms = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
+        using var sharpStream = SharpCompressStream.CreateNonDisposing(ms);
+        using var dataDescriptorStream = new DataDescriptorStream(sharpStream);
+        using var result = SharpCompressStream.Create(dataDescriptorStream, 128);
+
+        Assert.False(dataDescriptorStream.CanSeek);
+        Assert.IsType<SharpCompressStream>(result);
+        Assert.Same(dataDescriptorStream, result.BaseStream());
+
+        result.StartRecording();
+        Assert.Equal(1, result.ReadByte());
+        Assert.Equal(2, result.ReadByte());
+        result.Rewind();
+        Assert.Equal(1, result.ReadByte());
+    }
+
     [Fact]
     public void Create_WithNonSeekablePassthroughStream_CreatesBufferedWrapper()
     {