modelaudit 0.2.46__tar.gz → 0.2.47__tar.gz

{modelaudit-0.2.46 → modelaudit-0.2.47}/.release-please-manifest.json

@@ -1,4 +1,4 @@
 {
-  ".": "0.2.46",
+  ".": "0.2.47",
   "packages/modelaudit-picklescan": "0.1.6"
 }

{modelaudit-0.2.46 → modelaudit-0.2.47}/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.47](https://github.com/promptfoo/modelaudit/compare/v0.2.46...v0.2.47) (2026-06-05)
+
+### Bug Fixes
+
+- bind cache reads and writes to scanned file identity ([#1458](https://github.com/promptfoo/modelaudit/issues/1458)) ([860adab](https://github.com/promptfoo/modelaudit/commit/860adabe039437fcee6811a9cef561816ba25e74))
+- redact MetaGraph evidence previews ([#1473](https://github.com/promptfoo/modelaudit/issues/1473)) ([58139d9](https://github.com/promptfoo/modelaudit/commit/58139d98cd6c20ddadc379ee476f2e51aa4b798e))
+- redact Torch7 evidence examples ([#1467](https://github.com/promptfoo/modelaudit/issues/1467)) ([646857b](https://github.com/promptfoo/modelaudit/commit/646857bdd54f78334e79eb38896d3e0991810fca))
+
 ## [0.2.46](https://github.com/promptfoo/modelaudit/compare/v0.2.45...v0.2.46) (2026-06-05)
 
 ### Bug Fixes
@@ -196,6 +204,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Bug Fixes
 
+- redact secret-bearing TensorFlow MetaGraph executable previews and correlation examples
+- redact credential-shaped Torch7 evidence and detect execution primitives across chunk boundaries and alternate Lua syntax
+- bind cache reads and writes to complete file and pathname identities captured before scanning
 - bind SBOM hashing to stable scan-root descriptors and omit hashes for outside, swapped, or missing local symlink targets
 - detect native execution modules and nested serialized callables in Keras configs without promoting unimportable dotted native-module paths
 - classify noncanonical Keras versions inside wholly vulnerable numeric ranges and avoid over-attributing wildcard fixed lines

{modelaudit-0.2.46 → modelaudit-0.2.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelaudit
-Version: 0.2.46
+Version: 0.2.47
 Summary: Static scanning library for detecting malicious code, potential backdoor indicators, and other security risks in ML model files
 Project-URL: Repository, https://github.com/promptfoo/modelaudit
 Project-URL: Homepage, https://github.com/promptfoo/modelaudit

{modelaudit-0.2.46 → modelaudit-0.2.47}/modelaudit/cache/adaptive_cache_keys.py

@@ -64,10 +64,14 @@ class AdaptiveCacheKeyGenerator:
         self.cache_expiry = 5.0  # Cache fingerprints for 5 seconds
 
     def generate_key_material_with_stat_reuse(
-        self, file_path: str, stat_result: os.stat_result
+        self,
+        file_path: str,
+        stat_result: os.stat_result,
+        content_hash: str | None = None,
     ) -> tuple[str, str | None]:
         """Generate a cache key plus any content hash already needed for that key."""
         fingerprint = FileFingerprint.from_stat(file_path, stat_result)
+        fingerprint.content_hash = content_hash
 
         # Use content hash strategy based on file size
         if self._should_use_content_hash(stat_result.st_size):

{modelaudit-0.2.46 → modelaudit-0.2.47}/modelaudit/cache/batch_operations.py

@@ -9,6 +9,7 @@ from typing import Any
 from .adaptive_cache_keys import AdaptiveCacheKeyGenerator
 from .cache_manager import CacheManager
 from .cache_policy import should_cache_scan_result
+from .scan_results_cache import ScannedFileIdentity, ScanResultsCache
 
 logger = logging.getLogger(__name__)
 
@@ -48,6 +49,12 @@ class BatchCacheOperations:
         # Prepare cache lookups with stat collection
         for file_path in file_paths:
             try:
+                if self.cache_manager.cache is not None and self.cache_manager.cache._path_has_symlink_component(
+                    file_path
+                ):
+                    logger.debug("Bypassing batch cache lookup for symlinked path %s", file_path)
+                    results[file_path] = None
+                    continue
                 stat_result = os.stat(file_path)
                 cache_key = self.cache_manager.cache.generate_cache_key(
                     file_path,
@@ -146,6 +153,7 @@ class BatchCacheOperations:
         scan_results: list[tuple[str, dict[str, Any], int | None]],
         max_workers: int = 2,
         version_context: dict[str, Any] | None = None,
+        expected_file_identities: dict[str, ScannedFileIdentity] | None = None,
     ) -> int:
         """
         Store multiple scan results in cache with batch optimization.
@@ -153,42 +161,53 @@ class BatchCacheOperations:
         Args:
             scan_results: List of (file_path, scan_result, scan_duration_ms) tuples
             max_workers: Maximum number of concurrent I/O operations
+            expected_file_identities: File stat, hash, and change tokens captured with each scan result
 
         Returns:
             Number of successfully stored results
         """
-        if not self.cache_manager.enabled or not self.cache_manager.cache:
-            return 0
-
-        stored_count = 0
-
-        # Use moderate concurrency for write operations (less than reads)
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_to_path = {
-                executor.submit(
-                    self._store_single_result,
-                    file_path,
-                    scan_result,
-                    scan_duration_ms,
-                    version_context,
-                ): file_path
-                for file_path, scan_result, scan_duration_ms in scan_results
-            }
-
-            for future in as_completed(future_to_path):
-                file_path = future_to_path[future]
-                try:
-                    success = future.result()
-                    if success:
-                        stored_count += 1
-                        logger.debug(f"Batch stored: {os.path.basename(file_path)}")
+        cache = self.cache_manager.cache
+        try:
+            if not self.cache_manager.enabled or cache is None:
+                return 0
+
+            stored_count = 0
+
+            # Use moderate concurrency for write operations (less than reads)
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                future_to_path = {
+                    executor.submit(
+                        self._store_single_result,
+                        file_path,
+                        scan_result,
+                        scan_duration_ms,
+                        version_context,
+                        expected_file_identities.get(file_path) if expected_file_identities is not None else None,
+                    ): file_path
+                    for file_path, scan_result, scan_duration_ms in scan_results
+                }
+
+                for future in as_completed(future_to_path):
+                    file_path = future_to_path[future]
+                    try:
+                        success = future.result()
+                        if success:
+                            stored_count += 1
+                            logger.debug(f"Batch stored: {os.path.basename(file_path)}")
+                        else:
+                            logger.debug(f"Batch store failed: {os.path.basename(file_path)}")
+                    except Exception as e:
+                        logger.warning(f"Failed to store cache result for {file_path}: {e}")
+
+            logger.debug(f"Batch store complete: {stored_count}/{len(scan_results)} results stored")
+            return stored_count
+        finally:
+            if expected_file_identities is not None:
+                for identity in expected_file_identities.values():
+                    if cache is not None:
+                        cache.release_ancestor_identity(identity[-1])
                     else:
-                        logger.debug(f"Batch store failed: {os.path.basename(file_path)}")
-                except Exception as e:
-                    logger.warning(f"Failed to store cache result for {file_path}: {e}")
-
-        logger.debug(f"Batch store complete: {stored_count}/{len(scan_results)} results stored")
-        return stored_count
+                        ScanResultsCache.release_ancestor_identity(identity[-1])
 
     def _store_single_result(
         self,
@@ -196,18 +215,29 @@ class BatchCacheOperations:
         scan_result: dict[str, Any],
         scan_duration_ms: int | None,
         version_context: dict[str, Any] | None,
+        expected_file_identity: ScannedFileIdentity | None,
     ) -> bool:
         """Store a single result and return success status."""
         try:
             if not should_cache_scan_result(scan_result):
                 logger.debug(f"Skipping batch cache store for operational result from {os.path.basename(file_path)}")
                 return False
+            if expected_file_identity is None:
+                logger.debug(f"Skipping unbound batch cache store for {os.path.basename(file_path)}")
+                return False
+            expected_file_stat, expected_file_hash, expected_change_token, expected_ancestor_identity = (
+                expected_file_identity
+            )
 
             return self.cache_manager.store_result(
                 file_path,
                 scan_result,
                 scan_duration_ms,
                 version_context=version_context,
+                expected_file_stat=expected_file_stat,
+                expected_file_hash=expected_file_hash,
+                expected_change_token=expected_change_token,
+                expected_ancestor_identity=expected_ancestor_identity,
             )
         except Exception as e:
             logger.debug(f"Failed to store result for {file_path}: {e}")
@@ -226,6 +256,10 @@ class BatchCacheOperations:
         # Warm up the key generator's fingerprint cache
         for file_path in file_paths[:50]:  # Limit to avoid memory bloat
             try:
+                if self.cache_manager.cache is not None and self.cache_manager.cache._path_has_symlink_component(
+                    file_path
+                ):
+                    continue
                 stat_result = os.stat(file_path)
                 # This will cache the fingerprint
                 self.cache_manager.key_generator.generate_key_with_stat_reuse(file_path, stat_result)

{modelaudit-0.2.46 → modelaudit-0.2.47}/modelaudit/cache/cache_manager.py

@@ -8,7 +8,7 @@ from typing import Any
 
 from .adaptive_cache_keys import AdaptiveCacheKeyGenerator
 from .cache_policy import cached_scan_result_dependencies_available, should_cache_scan_result
-from .scan_results_cache import ScanResultsCache
+from .scan_results_cache import AncestorIdentity, ScannedFileIdentity, ScanResultsCache
 
 logger = logging.getLogger(__name__)
 
@@ -50,11 +50,15 @@ class CacheManager:
         if not self.enabled or not self.cache:
             return None
 
-        cached_result = self.cache.get_cached_result(file_path, version_context=version_context)
-        if cached_result is not None and not cached_scan_result_dependencies_available(cached_result):
-            logger.debug(f"Bypassing cached result with unavailable scanner dependencies: {Path(file_path).name}")
-            return None
-        return cached_result
+        cached_result, file_identity = self.get_cached_result_with_identity(
+            file_path,
+            version_context=version_context,
+        )
+        try:
+            return cached_result
+        finally:
+            if file_identity is not None:
+                self.cache.release_ancestor_identity(file_identity[-1])
 
     def get_cached_result_with_stat(
         self,
@@ -75,15 +79,33 @@ class CacheManager:
         if not self.enabled or not self.cache:
             return None
 
-        cached_result = self.cache.get_cached_result_with_stat(
+        cached_result, file_identity = self.get_cached_result_with_identity(
+            file_path,
+            version_context=version_context,
+        )
+        try:
+            return cached_result
+        finally:
+            if file_identity is not None:
+                self.cache.release_ancestor_identity(file_identity[-1])
+
+    def get_cached_result_with_identity(
+        self,
+        file_path: str,
+        version_context: dict[str, Any] | None = None,
+    ) -> tuple[dict[str, Any] | None, ScannedFileIdentity | None]:
+        """Return a cache lookup and retain the monitored identity for a miss scan."""
+        if not self.enabled or not self.cache:
+            return None, None
+
+        cached_result, file_identity = self.cache.get_cached_result_with_identity(
             file_path,
-            stat_result,
             version_context=version_context,
         )
         if cached_result is not None and not cached_scan_result_dependencies_available(cached_result):
             logger.debug(f"Bypassing cached result with unavailable scanner dependencies: {Path(file_path).name}")
-            return None
-        return cached_result
+            return None, file_identity
+        return cached_result, file_identity
 
     def store_result(
         self,
@@ -91,6 +113,10 @@ class CacheManager:
         scan_result: dict[str, Any],
         scan_duration_ms: int | None = None,
         version_context: dict[str, Any] | None = None,
+        expected_file_stat: os.stat_result | None = None,
+        expected_file_hash: str | None = None,
+        expected_change_token: int | None = None,
+        expected_ancestor_identity: AncestorIdentity | None = None,
     ) -> bool:
         """
         Store scan result in cache.
@@ -99,11 +125,25 @@ class CacheManager:
             file_path: Path to file that was scanned
             scan_result: Scan result to cache
             scan_duration_ms: Optional scan duration
+            version_context: Optional cache version context for config-sensitive invalidation
+            expected_file_stat: File metadata captured before the scan
+            expected_file_hash: Secure content hash captured before the scan
+            expected_change_token: Platform-specific modification token captured before the scan
+            expected_ancestor_identity: Ancestor directory identities captured before the scan
         """
         if not self.enabled or not self.cache:
             return False
 
-        return self.cache.store_result(file_path, scan_result, scan_duration_ms, version_context=version_context)
+        return self.cache.store_result(
+            file_path,
+            scan_result,
+            scan_duration_ms,
+            version_context=version_context,
+            expected_file_stat=expected_file_stat,
+            expected_file_hash=expected_file_hash,
+            expected_change_token=expected_change_token,
+            expected_ancestor_identity=expected_ancestor_identity,
+        )
 
     def cached_scan(
         self,
@@ -127,26 +167,29 @@ class CacheManager:
         """
         # Try cache first
         start_time = time.time()
-        cached_result = self.get_cached_result(file_path, version_context=version_context)
+        pre_scan_identity: ScannedFileIdentity | None = None
+        try:
+            cached_result, pre_scan_identity = self.get_cached_result_with_identity(
+                file_path,
+                version_context=version_context,
+            )
 
-        if cached_result is not None:
-            cache_lookup_time = (time.time() - start_time) * 1000
-            logger.debug(f"Cache hit for {Path(file_path).name} (lookup: {cache_lookup_time:.1f}ms)")
+            if cached_result is not None:
+                cache_lookup_time = (time.time() - start_time) * 1000
+                logger.debug(f"Cache hit for {Path(file_path).name} (lookup: {cache_lookup_time:.1f}ms)")
 
-            # Add cache metadata to result
-            if isinstance(cached_result, dict):
-                cached_result["_cache_info"] = {"cache_hit": True, "lookup_time_ms": cache_lookup_time}
+                # Add cache metadata to result
+                if isinstance(cached_result, dict):
+                    cached_result["_cache_info"] = {"cache_hit": True, "lookup_time_ms": cache_lookup_time}
 
-            return cached_result
-
-        # Cache miss - validate file exists before scanning
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
+                return cached_result
 
-        logger.debug(f"Cache miss for {Path(file_path).name}, proceeding with scan")
-        scan_start = time.time()
+            # Cache miss - validate file exists before scanning
+            if not os.path.exists(file_path):
+                raise FileNotFoundError(f"File not found: {file_path}")
 
-        try:
+            logger.debug(f"Cache miss for {Path(file_path).name}, proceeding with scan")
+            scan_start = time.time()
             scan_result = scanner_func(file_path, *args, **kwargs)
             scan_duration = (time.time() - scan_start) * 1000
 
@@ -154,9 +197,20 @@ class CacheManager:
             if isinstance(scan_result, dict):
                 scan_result["_cache_info"] = {"cache_hit": False, "scan_duration_ms": scan_duration}
 
-            if should_cache_scan_result(scan_result):
-                self.store_result(file_path, scan_result, int(scan_duration), version_context=version_context)
-            else:
+            cacheable_result = should_cache_scan_result(scan_result)
+            if cacheable_result and pre_scan_identity is not None:
+                pre_scan_stat, pre_scan_hash, pre_scan_change_token, pre_scan_ancestor_identity = pre_scan_identity
+                self.store_result(
+                    file_path,
+                    scan_result,
+                    int(scan_duration),
+                    version_context=version_context,
+                    expected_file_stat=pre_scan_stat,
+                    expected_file_hash=pre_scan_hash,
+                    expected_change_token=pre_scan_change_token,
+                    expected_ancestor_identity=pre_scan_ancestor_identity,
+                )
+            elif not cacheable_result:
                 logger.debug(f"Skipping cache store for operational result from {Path(file_path).name}")
 
             return scan_result  # type: ignore[no-any-return]
@@ -164,6 +218,9 @@ class CacheManager:
         except Exception as e:
             logger.error(f"Scan failed for {file_path}: {e}")
             raise
+        finally:
+            if self.cache is not None and pre_scan_identity is not None:
+                self.cache.release_ancestor_identity(pre_scan_identity[-1])
 
     def get_stats(self) -> dict[str, Any]:
         """Get cache statistics."""