Add compression magic number detection to System.Formats.Tar with helpful error messages

src/libraries/System.Formats.Tar/src/Resources/Strings.resx

@@ -188,7 +188,7 @@
     <value>An attempt was made to move the position before the beginning of the stream.</value>
   </data>
   <data name="TarInvalidNumber" xml:space="preserve">
-    <value>Unable to parse number.</value>
+    <value>The TAR archive is corrupted or invalid.</value>
   </data>
   <data name="TarInvalidChecksum" xml:space="preserve">
     <value>Checksum validation failed. The archive might be corrupted.</value>
@@ -211,4 +211,7 @@
   <data name="ExtHeaderInvalidRecords" xml:space="preserve">
     <value>The extended header contains invalid records.</value>
   </data>
+  <data name="TarCompressionArchiveDetected" xml:space="preserve">
+    <value>The file appears to be a {0} archive. TAR format expected.</value>
+  </data>
 </root>

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Read.cs

@@ -370,7 +370,20 @@ private async Task ProcessDataBlockAsync(Stream archiveStream, bool copyData, Ca
             {
                 return null;
             }
-            int checksum = (int)TarHelpers.ParseOctal<uint>(spanChecksum);
+
+            int checksum;
+            try
+            {
+                checksum = (int)TarHelpers.ParseOctal<uint>(spanChecksum);
+            }
+            catch (InvalidDataException)
+            {
+                // Check if this might be a compressed file by looking at the buffer for compression magic numbers
+                ThrowIfCompressedArchive(buffer);
+                // If not a compressed file, re-throw the original parsing exception
+                throw;
+            }
+
             // Zero checksum means the whole header is empty
             if (checksum == 0)
             {
@@ -789,5 +802,83 @@ private static bool TryGetNextExtendedAttribute(
             buffer = buffer.Slice(newlinePos + 1);
             return true;
         }
+
+        /// <summary>
+        /// Analyzes the buffer for known compression format magic numbers and throws an InvalidDataException
+        /// with a specific error message if a compression format is detected.
+        /// If no compression format is detected, the method returns without throwing.
+        /// </summary>
+        /// <exception cref="InvalidDataException">Thrown if a compression format is detected.</exception>
+        private static void ThrowIfCompressedArchive(ReadOnlySpan<byte> buffer)
+        {
+            if (buffer.Length < 2)
+            {
+                return;
+            }
+
+            byte firstByte = buffer[0];
+            switch (firstByte)
+            {
+                case 0x28: // Zstandard
+                    if (buffer.Length >= 4 &&
+                        buffer[1] == 0xB5 && buffer[2] == 0x2F && buffer[3] == 0xFD)
+                    {
+                        throw new InvalidDataException(SR.Format(SR.TarCompressionArchiveDetected, "Zstandard"));
+                    }
+                    break;
+
+                case 0x37: // 7-Zip
+                    if (buffer.Length >= 6 &&
+                        buffer[1] == 0x7A && buffer[2] == 0xBC &&
+                        buffer[3] == 0xAF && buffer[4] == 0x27 && buffer[5] == 0x1C)
+                    {
+                        throw new InvalidDataException(SR.Format(SR.TarCompressionArchiveDetected, "7-Zip"));
+                    }
+                    break;
+
+                case 0x50: // ZIP files start with "PK"
+                    if (buffer.Length >= 2 && buffer[1] == 0x4B)
+                    {
+                        throw new InvalidDataException(SR.Format(SR.TarCompressionArchiveDetected, "ZIP"));
+                    }
+                    break;
+
+                case 0x1F: // GZIP
+                    if (buffer.Length >= 2 && buffer[1] == 0x8B)
+                    {
+                        throw new InvalidDataException(SR.Format(SR.TarCompressionArchiveDetected, "GZIP"));
+                    }
+                    break;
+
+                case 0x42: // BZIP2 - "BZh"
+                    if (buffer.Length >= 3 && buffer[1] == 0x5A && buffer[2] == 0x68)
+                    {
+                        throw new InvalidDataException(SR.Format(SR.TarCompressionArchiveDetected, "BZIP2"));
+                    }
+                    break;
+
+                case 0xFD: // XZ
+                    if (buffer.Length >= 6 &&
+                        buffer[1] == 0x37 && buffer[2] == 0x7A &&
+                        buffer[3] == 0x58 && buffer[4] == 0x5A && buffer[5] == 0x00)
+                    {
+                        throw new InvalidDataException(SR.Format(SR.TarCompressionArchiveDetected, "XZ"));
+                    }
+                    break;
+
+                case 0x78: // ZLIB (deflate compression)
+                    if (buffer.Length >= 2)
+                    {
+                        byte secondByte = buffer[1];
+                        if (secondByte == 0x01 || secondByte == 0x5E || secondByte == 0x9C ||
+                            secondByte == 0xDA || secondByte == 0x20 || secondByte == 0x7D ||
+                            secondByte == 0xBB || secondByte == 0xF9)
+                        {
+                            throw new InvalidDataException(SR.Format(SR.TarCompressionArchiveDetected, "ZLIB"));
+                        }
+                    }
+                    break;
+            }
+        }
     }
 }

src/libraries/System.Formats.Tar/tests/TarReader/TarReader.Tests.cs

@@ -159,7 +159,7 @@ public void TarReader_InvalidChecksum_ThrowsException(bool corrupted)
 
             if (corrupted)
             {
-                Assert.Contains("parse", exception.Message);
+                Assert.Contains("corrupted", exception.Message);
             }
             else
             {