Commit d6c441b63 for clamav.net

commit d6c441b630c689b505eedef1d1860104e15a0f21
Author: John Humlick <15677335+jhumlick@users.noreply.github.com>
Date:   Thu Nov 19 15:28:17 2026 -0800

    Fix XAR limit handling and cache regressions

    Mark scans as non-cacheable when TOC inflation hits a size limit, and
    extend the same-engine regression test to cover relaxing that limit.
    Use portable integer conversions in the XAR test fixture.

    CLAM-3094

diff --git a/libclamav/xar.c b/libclamav/xar.c
index 0f94e1d3c..070e31ec4 100644
--- a/libclamav/xar.c
+++ b/libclamav/xar.c
@@ -607,6 +607,8 @@ int cli_scanxar(cli_ctx *ctx)
         rc = xar_inflate_toc(ctx, compressed_toc, (size_t)hdr.toc_length_compressed, &toc, &toc_length);
     }
     if (rc != CL_SUCCESS) {
+        if (ctx->abort_scan || rc == CL_ETIMEOUT || rc == CL_EMAXFILES || rc == CL_EMAXSIZE)
+            emax_reached(ctx);
         return rc;
     }

diff --git a/unit_tests/check_clamav.c b/unit_tests/check_clamav.c
index 3b138e606..4885fd0f1 100644
--- a/unit_tests/check_clamav.c
+++ b/unit_tests/check_clamav.c
@@ -6,6 +6,8 @@

 #include <stdlib.h>
 #include <limits.h>
+#include <inttypes.h>
+#include <stdint.h>
 #include <fcntl.h>
 #include <string.h>
 #include <check.h>
@@ -319,10 +321,15 @@ START_TEST(test_xar_incomplete_scan_is_not_clean_cached)
     unsigned char header[28] = {0};
     unsigned char *member = NULL;
     unsigned char *compressed_toc = NULL;
-    unsigned long member_size, compressed_toc_size;
+    size_t member_size;
+    uLong zlib_toc_size;
+    uLongf compressed_toc_size;
     unsigned long scanned = 0;
     size_t toc_size;
+    uint64_t compressed_toc_length_field, toc_length_field;
+    long long original_maxfiles, original_maxfilesize;
     int i, toc_length, added;
+    long xar_length;
     FILE *member_file = NULL, *xar_file = NULL;
     struct cl_scan_options options;
     int ret;
@@ -333,7 +340,7 @@ START_TEST(test_xar_incomplete_scan_is_not_clean_cached)
     long member_length = ftell(member_file);
     ck_assert_msg(member_length > 0, "empty %s", member_path);
     ck_assert_msg(fseek(member_file, 0, SEEK_SET) == 0, "rewind %s", member_path);
-    member_size = (unsigned long)member_length;
+    member_size = (size_t)member_length;
     member = malloc(member_size);
     ck_assert_msg(member != NULL, "allocate XAR member");
     ck_assert_msg(fread(member, 1, member_size, member_file) == member_size, "read %s", member_path);
@@ -353,36 +360,45 @@ START_TEST(test_xar_incomplete_scan_is_not_clean_cached)
     }
     added = snprintf(toc + toc_length, sizeof(toc) - (size_t)toc_length,
                      "<file><name>clam.exe</name><type>file</type><data>"
-                     "<length>%lu</length><offset>100</offset><size>%lu</size>"
-                     "</data></file></toc></xar>", member_size, member_size);
+                     "<length>%" PRIu64 "</length><offset>100</offset><size>%" PRIu64 "</size>"
+                     "</data></file></toc></xar>", (uint64_t)member_size, (uint64_t)member_size);
     ck_assert_msg(added > 0 && (size_t)added < sizeof(toc) - (size_t)toc_length,
                   "append signature member to XAR TOC");
     toc_length += added;
     toc_size = (size_t)toc_length;
-    compressed_toc_size = compressBound(toc_size);
-    compressed_toc = malloc(compressed_toc_size);
+    ck_assert_msg(toc_size <= ULONG_MAX, "XAR TOC exceeds zlib input length type");
+    zlib_toc_size     = (uLong)toc_size;
+    compressed_toc_size = compressBound(zlib_toc_size);
+    ck_assert_msg((uint64_t)compressed_toc_size <= (uint64_t)SIZE_MAX,
+                  "compressed XAR TOC exceeds size_t");
+    compressed_toc = malloc((size_t)compressed_toc_size);
     ck_assert_msg(compressed_toc != NULL, "allocate compressed XAR TOC");
     ck_assert_msg(compress(compressed_toc, &compressed_toc_size,
-                           (const Bytef *)toc, toc_size) == Z_OK,
+                           (const Bytef *)toc, zlib_toc_size) == Z_OK,
                   "compress XAR TOC");

     /* XAR's header fields are big-endian. */
     header[0] = 0x78; header[1] = 0x61; header[2] = 0x72; header[3] = 0x21;
     header[5] = 28;
+    compressed_toc_length_field = (uint64_t)compressed_toc_size;
+    toc_length_field            = (uint64_t)toc_size;
     for (i = 0; i < 8; i++) {
-        header[8 + i] = (unsigned char)(compressed_toc_size >> (56 - 8 * i));
-        header[16 + i] = (unsigned char)(toc_size >> (56 - 8 * i));
+        header[8 + i]  = (unsigned char)(compressed_toc_length_field >> (56 - 8 * i));
+        header[16 + i] = (unsigned char)(toc_length_field >> (56 - 8 * i));
     }

     snprintf(xar_path, sizeof(xar_path), "%s" PATHSEP "xar-cache-regression.xar", OBJDIR);
     xar_file = fopen(xar_path, "wb");
     ck_assert_msg(xar_file != NULL, "create %s", xar_path);
     ck_assert_msg(fwrite(header, 1, sizeof(header), xar_file) == sizeof(header), "write XAR header");
-    ck_assert_msg(fwrite(compressed_toc, 1, compressed_toc_size, xar_file) == compressed_toc_size,
+    ck_assert_msg(fwrite(compressed_toc, 1, (size_t)compressed_toc_size, xar_file) == (size_t)compressed_toc_size,
                   "write compressed XAR TOC");
     for (i = 0; i < 20; i++)
         ck_assert_msg(fwrite("clean", 1, 5, xar_file) == 5, "write clean XAR member %d", i);
     ck_assert_msg(fwrite(member, 1, member_size, xar_file) == member_size, "write second XAR member");
+    ck_assert_msg(fflush(xar_file) == 0, "flush %s", xar_path);
+    xar_length = ftell(xar_file);
+    ck_assert_msg(xar_length > 0, "get XAR fixture size");
     ck_assert_msg(fclose(xar_file) == 0, "close %s", xar_path);
     xar_file = NULL;
     free(compressed_toc);
@@ -390,6 +406,10 @@ START_TEST(test_xar_incomplete_scan_is_not_clean_cached)

     memset(&options, 0, sizeof(options));
     options.parse |= ~0;
+    original_maxfiles = cl_engine_get_num(g_engine, CL_ENGINE_MAX_FILES, NULL);
+    original_maxfilesize = cl_engine_get_num(g_engine, CL_ENGINE_MAX_FILESIZE, NULL);
+    ck_assert_msg(original_maxfiles >= 0 && original_maxfilesize >= 0,
+                  "read original engine limits");

     /* MaxFiles allows the first member but blocks later members, so this
      * incomplete archive result must not be cached as clean. */
@@ -408,6 +428,28 @@ START_TEST(test_xar_incomplete_scan_is_not_clean_cached)
     ck_assert_msg(ret == CL_VIRUS, "second XAR scan should detect skipped member: %s", cl_strerror(ret));
     ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"),
                   "virusname: %s", virname ? virname : "(null)");
+
+    /* The archive itself fits MaxFileSize, but the expanded TOC does not.
+     * Relaxing the limit on this same engine must rescan the XAR and detect
+     * the member instead of reusing a clean-cache result. */
+    ck_assert_msg(cl_engine_set_num(g_engine, CL_ENGINE_MAX_FILESIZE, xar_length) == CL_SUCCESS,
+                  "set TOC-limiting MaxFileSize");
+    ret = cl_scanfile(xar_path, &virname, &scanned, g_engine, &options);
+    ck_assert_msg(ret == CL_CLEAN, "TOC-limited XAR scan: %s", cl_strerror(ret));
+
+    ck_assert_msg(cl_engine_set_num(g_engine, CL_ENGINE_MAX_FILESIZE, 1024 * 1024) == CL_SUCCESS,
+                  "raise MaxFileSize");
+    virname = NULL;
+    scanned = 0;
+    ret = cl_scanfile(xar_path, &virname, &scanned, g_engine, &options);
+    ck_assert_msg(ret == CL_VIRUS, "TOC-limit-relaxed XAR scan should detect skipped member: %s",
+                  cl_strerror(ret));
+    ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"),
+                  "virusname: %s", virname ? virname : "(null)");
+    ck_assert_msg(cl_engine_set_num(g_engine, CL_ENGINE_MAX_FILES, original_maxfiles) == CL_SUCCESS,
+                  "restore MaxFiles");
+    ck_assert_msg(cl_engine_set_num(g_engine, CL_ENGINE_MAX_FILESIZE, original_maxfilesize) == CL_SUCCESS,
+                  "restore MaxFileSize");
     cli_unlink(xar_path);
 }
 END_TEST