WinZip AES (AE-2): unverified metadata silently changes what ZipArchive returns, including reading an entry as empty #136787

using System;
using System.Buffers.Binary;
using System.IO;
using System.IO.Compression;
using System.Linq;

// net11.0, no arguments. Builds one AES-256 archive in memory, then reads it back
// three times: untouched, with the declared uncompressed size lowered, and with the
// inner compression method changed. Only metadata is edited; the encrypted bytes and
// the 10-byte authentication code are never touched.
class Repro
{
    const string Password = "correct horse battery staple";

    static byte[] s_plaintext;

    static void Main()
    {
        s_plaintext = new byte[64 * 1024];
        new Random(1234).NextBytes(s_plaintext);        // incompressible

        byte[] aes = Build(ZipEncryptionMethod.Aes256);
        byte[] plain = Build(ZipEncryptionMethod.None);

        Console.WriteLine("AES-256 entry, 65536 bytes of content:");
        Read("  untouched                    ", aes, true);
        Read("  declared size -> 1024        ", SetDeclaredSize(aes, 1024), true);
        Read("  declared size -> 0           ", SetDeclaredSize(aes, 0), true);
        Read("  inner method Deflate->Stored ", SetInnerMethod(aes, 0), true);

        Console.WriteLine("the same edits on an unencrypted entry, for comparison:");
        Read("  untouched                    ", plain, false);
        Read("  declared size -> 1024        ", SetDeclaredSize(plain, 1024), false);
        Read("  declared size -> 0           ", SetDeclaredSize(plain, 0), false);
    }

    static byte[] Build(ZipEncryptionMethod enc)
    {
        using MemoryStream ms = new MemoryStream();
        using (ZipArchive zip = new ZipArchive(ms, ZipArchiveMode.Create, leaveOpen: true))
        {
            ZipArchiveEntry e = enc == ZipEncryptionMethod.None
                ? zip.CreateEntry("data.bin", CompressionLevel.Optimal)
                : zip.CreateEntry("data.bin", CompressionLevel.Optimal, Password, enc);
            using Stream s = enc == ZipEncryptionMethod.None ? e.Open() : e.Open(Password);
            s.Write(s_plaintext);
        }
        return ms.ToArray();
    }

    // Uncompressed size, in the local file header and the central directory.
    static byte[] SetDeclaredSize(byte[] zip, uint value)
    {
        byte[] b = (byte[])zip.Clone();
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(22), value);
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(CentralDirectory(b) + 24), value);
        return b;
    }

    // Inner compression method inside the 0x9901 AES extra field of the central directory:
    // tag(2) size(2) vendorVersion(2) "AE"(2) strength(1) method(2).
    static byte[] SetInnerMethod(byte[] zip, ushort method)
    {
        byte[] b = (byte[])zip.Clone();
        int cd = CentralDirectory(b);
        int nameLen = BinaryPrimitives.ReadUInt16LittleEndian(b.AsSpan(cd + 28));
        BinaryPrimitives.WriteUInt16LittleEndian(b.AsSpan(cd + 46 + nameLen + 4 + 5), method);
        return b;
    }

    static void Read(string label, byte[] zip, bool encrypted)
    {
        Console.Write(label);
        try
        {
            using MemoryStream src = new MemoryStream(zip);
            using ZipArchive z = new ZipArchive(src, ZipArchiveMode.Read);
            ZipArchiveEntry e = z.GetEntry("data.bin");
            long declared = e.Length;

            using MemoryStream dst = new MemoryStream();
            using (Stream s = encrypted ? e.Open(Password) : e.Open())
            {
                s.CopyTo(dst);
            }

            byte[] got = dst.ToArray();
            string what =
                got.AsSpan().SequenceEqual(s_plaintext) ? "the original content" :
                got.Length <= s_plaintext.Length && got.AsSpan().SequenceEqual(s_plaintext.AsSpan(0, got.Length))
                    ? $"a truncated prefix of the {s_plaintext.Length}-byte content" :
                    "different content";
            Console.WriteLine($"-> Length={declared,6}, read {got.Length,6} bytes with no error: {what}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"-> rejected: {ex.GetType().Name}: {ex.Message}");
        }
    }

    static int CentralDirectory(byte[] b)
    {
        byte[] eocd = "PK\u0005\u0006".Select(c => (byte)c).ToArray();
        for (int i = b.Length - eocd.Length; i >= 0; i--)
        {
            if (b.AsSpan(i, eocd.Length).SequenceEqual(eocd))
            {
                return BinaryPrimitives.ReadInt32LittleEndian(b.AsSpan(i + 16));
            }
        }
        throw new InvalidDataException("end of central directory not found");
    }
}

// AE-2 encrypted entries store CRC as 0 so skip CRC validation for those.
// AE-1 version entries store a valid CRC.
if (IsAesEncrypted && _aeVersion == 2)
{
    return decompressedStream;
}

return new CrcValidatingReadStream(decompressedStream, _crc32, _uncompressedSize);

case ZipCompressionMethod.Deflate:
    uncompressedStream = new DeflateStream(compressedStreamToRead, CompressionMode.Decompress, _uncompressedSize);