Add compression magic number detection to System.Formats.Tar with helpful error messages (#119996)

This PR improves error messages when users attempt to read compressed
TAR archives. When TAR header parsing fails due to an invalid checksum
field, the code now checks if the file might be a compressed archive
(GZIP, BZIP2, XZ, ZIP, ZLIB, 7-Zip, or Zstandard) by examining
compression magic numbers. If a compression format is detected, it
throws a clear, localized error message indicating the specific
compression format detected (e.g., "The file appears to be a GZIP
archive. TAR format expected.").

Fixes #89056

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: iremyux

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,93 @@ 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 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 0x28: // Could be Zstandard or ZLIB
+                    if (buffer.Length >= 4 &&
+                        buffer[1] == 0xB5 && buffer[2] == 0x2F && buffer[3] == 0xFD)
+                    {
+                        throw new InvalidDataException(SR.Format(SR.TarCompressionArchiveDetected, "Zstandard"));
+                    }
+                    // If not Zstandard, check if it's ZLIB
+                    goto CheckZlib;
+
+                // ZLIB (deflate compression) - various compression methods and window sizes
+                case 0x08:
+                case 0x18:
+                case 0x38:
+                case 0x48:
+                case 0x58:
+                case 0x68:
+                case 0x78:
+                CheckZlib:
+                    if (buffer.Length >= 2)
+                    {
+                        byte secondByte = buffer[1];
+                        // Check if this is a valid ZLIB header (must be divisible by 31)
+                        if (((firstByte * 256) + secondByte) % 31 == 0)
+                        {
+                            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
             {