aquasecurity/trivy
64.1
Adequate · 13 November 2026
110.8k
lines of production code
Go
primary language
6
measurements over time
What this system is
Features
Add .NET deps.json parser and WordPress version detection
The tool now parses .NET Core \\*.deps.json\ files to extract runtime packages, build a dependency graph, and identify the root project, including support for self-contained deployments where the bundled runtime is reported with the \runtimepack.\ prefix stripped. Additionally, it can now detect the installed WordPress version by parsing the \$wp\_version\ variable from \version.php\.
pkg/dependency/parser/dotnet · high confidence
Add .deps.json analyzer for .NET Core dependency detection
Users can now have .NET Core projects analyzed via .deps.json files. A new analyzer has been added to detect and parse these dependency manifests, extracting package names, versions, and source line locations for reported vulnerabilities.
pkg/fanal/analyzer/language/dotnet/deps · high confidence
Add APK repository analyzer for Alpine Linux
A new analyzer has been added to detect and parse the \etc/apk/repositories\ file, enabling the identification of the OS family (Alpine) and the specific release version (including edge releases) from the repository URLs. This allows the tool to correctly recognize Alpine Linux distributions based on their package repository configuration.
pkg/fanal/analyzer/repo · high confidence
Add ARM adapter for Azure App Service resources
Users can now have Azure App Service configurations (Web Apps and Function Apps) validated against security policies. This change introduces the ARM adapter for the appservice package, which parses Azure Resource Manager deployments for Microsoft.Web/sites resources and extracts security-relevant settings such as HTTPS enforcement, client certificate requirements, identity types, authentication status, and runtime configurations (TLS version, HTTP/2, PHP/Python versions, FTPS state).
pkg/iac/adapters/arm/appservice · high confidence
Add ARM adapter for Azure Compute resources
The system now adapts Azure Resource Manager (ARM) templates for compute resources, including virtual machines (Linux and Windows) and managed disks. This allows the scanner to evaluate configurations such as disk encryption status, custom data, and Linux password authentication settings defined in ARM deployments.
pkg/iac/adapters/arm/compute · high confidence
Add ARM adapter for Azure Kubernetes Service (AKS) clusters
The system now adapts Azure Resource Manager (ARM) templates for AKS clusters, extracting key security and configuration properties such as RBAC status, private cluster enablement, API server authorized IP ranges, network policies, and agent pool details. This enables security scanning and compliance checks against Kubernetes cluster configurations defined in ARM deployments.
pkg/iac/adapters/arm/container · high confidence
Add ARM adapter for Azure Security Center configuration
Users can now have Azure Security Center settings (security contacts and subscription pricing tiers) detected from ARM templates. The new adapter in \pkg/iac/adapters/arm/securitycenter\ parses \Microsoft.Security/securityContacts\ resources to extract alert notification settings (including the new \notificationsSources\ format with minimal severity) and \Microsoft.Security/pricings\ resources to identify the pricing tier (e.g., Standard vs. Free).
pkg/iac/adapters/arm/securitycenter · high confidence
Add ARM adapter for Azure Storage Account configuration
Introduces a new adapter in the ARM (Azure Resource Manager) scanning pipeline that parses Azure Storage Account deployments into the internal security model. This adapter extracts key security configurations including network ACLs (bypass rules and default actions), TLS version requirements, HTTPS enforcement, public network access settings, and queue/blob logging properties, enabling security checks against these specific storage account attributes.
pkg/iac/adapters/arm/storage · high confidence
Add ARM template adapter for Azure network resources
Users can now have Azure network configurations defined in ARM templates scanned for misconfigurations. This change introduces the \pkg/iac/adapters/arm/network\ adapter, which parses \Microsoft.Network/networkSecurityGroups\, \Microsoft.Network/networkWatchers/flowLogs\, and \Microsoft.Network/networkInterfaces\ resources from ARM JSON deployments. It correctly handles security group rules including source/destination address prefixes and port ranges (both single values and lists), as well as network interface IP configurations and flow log retention policies, mapping them to the internal IAC types for rule evaluation.
pkg/iac/adapters/arm/network · high confidence
Add ARM template adapters for Azure Data Factory, Data Lake, and Synapse
New adapters have been added to parse Azure Resource Manager (ARM) templates for Azure Data Factory, Azure Data Lake Store, and Azure Synapse Analytics. These adapters extract key security-relevant properties—such as public network access for Data Factory, encryption state for Data Lake, and managed virtual network status for Synapse—enabling the scanner to evaluate these resources against security best practices.
pkg/iac/adapters/arm/datafactory, pkg/iac/adapters/arm/datalake, pkg/iac/adapters/arm/synapse · high confidence
Add Amazon Linux OS detection support
The system now detects Amazon Linux operating systems, including versions 1, 2, 2022, and 2023. This new analyzer reads release files (such as \etc/system-release\ and \usr/lib/system-release\) to identify the OS family and specific version name, enabling accurate vulnerability scanning for these environments.
pkg/fanal/analyzer/os/amazonlinux · high confidence
Add Azure Key Vault ARM adapter
The system now includes an adapter that converts Azure Resource Manager (ARM) deployments for Microsoft.KeyVault/vaults into the internal security model. This change enables scanning of Key Vault configurations, including vault settings like purge protection and soft-delete retention, as well as associated keys and secrets, allowing users to detect misconfigurations in their Azure Key Vault infrastructure.
pkg/iac/adapters/arm/keyvault · high confidence
Add Bottlerocket OS package detection and vulnerability scanning
Users scanning Bottlerocket-based containers will now have their OS packages detected and checked for known vulnerabilities. This change introduces a new inventory analyzer that parses the Bottlerocket application-inventory.json file to extract installed packages (including handling for RPM epochs and release strings) and a corresponding vulnerability scanner that matches these packages against Bottlerocket Security Advisories from the Trivy database.
_pkg/detector/ospkg/bottlerocket, pkg/fanal/analyzer/pkg/bottlerocket\inventory · high confidence
Add Bun lockfile analysis with license detection
The analyzer now supports the Bun package manager by introducing a new \bunLibraryAnalyzer\ that parses \bun.lock\ files to identify installed packages and their dependencies. This change extends the Node.js analysis capabilities to include Bun projects, automatically detecting package licenses from \package.json\ files within \node\_modules\ directories and reporting them alongside the dependency tree.
pkg/fanal/analyzer/language/nodejs/bun · high confidence
Add CocoaPods dependency parser for Swift projects
Users can now scan Swift projects that use CocoaPods for dependency management. A new parser in the Swift dependency analysis module reads the Podfile.lock to extract installed pod names, versions, and their dependency relationships, enabling vulnerability detection for CocoaPods-based applications.
pkg/dependency/parser/swift/cocoapods · high confidence
Add CocoaPods lock file analysis support
Users can now have Swift CocoaPods dependencies detected and analyzed. This change introduces a new analyzer that parses Podfile.lock files, extracting package names, versions, and dependency relationships so they can be included in vulnerability and license scans.
pkg/fanal/analyzer/language/swift/cocoapods · high confidence
Add Composer lock file parser with dev dependency support
The PHP dependency analysis now includes a new parser for Composer's \composer.lock\ file. This parser extracts both production and development dependencies, ensuring that production packages take precedence when duplicates exist. It also correctly identifies and marks development-only packages and resolves dependency relationships between them.
pkg/dependency/parser/php · high confidence
Add Conda package metadata analyzer
The tool now analyzes Conda package metadata files (JSON files located in conda-meta directories) to detect installed Conda packages. This new analyzer registers for the CondaPkg type, parsing package details such as name, version, and license from the metadata, and includes tests to verify correct parsing of valid package files and error handling for invalid ones.
pkg/fanal/analyzer/language/conda/meta · high confidence
Add CycloneDX SBOM report output format
Users can now export scan results in the CycloneDX Software Bill of Materials (SBOM) format. This change introduces a new writer in the report package that marshals Trivy findings into the CycloneDX JSON structure using the cyclonedx-go library, with HTML escaping disabled for the encoded output.
pkg/report/cyclonedx · high confidence
Add Dart pub dependency parser with SDK version resolution
Users can now scan Dart projects by parsing pubspec.lock files to identify dependencies. The new parser extracts package names and versions, classifying them as direct or indirect based on their dependency type. For dependencies sourced from the SDK (where the version is reported as 0.0.0), the parser can resolve the actual minimum version by interpreting SDK constraints (e.g., ^3.3.0 or \>=2.18.0), ensuring accurate version reporting for security analysis.
pkg/dependency/parser/dart · high confidence
Add DigitalOcean Terraform adapter for compute and spaces resources
The adapter in \pkg/iac/adapters/terraform/digitalocean\ now parses DigitalOcean Terraform configurations into an internal model. It adapts compute resources (droplets, firewalls, load balancers, and Kubernetes clusters) and spaces resources (buckets and bucket objects). For spaces buckets, the adapter defaults the ACL to 'private' if not explicitly set, ensuring consistent security posture for unconfigured storage.
pkg/iac/adapters/terraform/digitalocean · high confidence
Add EOL date data and display script for Debian and Ubuntu
The misc/eol directory now includes CSV data files (debian.csv, ubuntu.csv) containing release history and end-of-life dates for Debian and Ubuntu versions, along with a Go script (main.go) that reads these files and prints the EOL dates in a Go-compatible format. This provides the underlying data and tooling to display EOL warnings for operating systems that have reached their end of life.
misc/eol · high confidence
Add GKE Terraform adapter for Google Kubernetes Engine
Introduces a new adapter in the \pkg/iac/adapters/terraform/google/gke\ package that parses \google\_container\_cluster\ and \google\_container\_node\_pool\ Terraform resources. This enables the detection of security misconfigurations in GKE clusters by extracting settings such as network policies, master authorized networks, shielded nodes, legacy ABAC, autopilot mode, and auto-provisioning defaults into a structured internal model.
pkg/iac/adapters/terraform/google/gke · high confidence
Add GitHub Dependency Snapshots report format
Introduces a new report writer that generates JSON output compatible with GitHub Dependency Snapshots. This feature maps scanned packages to PURLs, distinguishes between direct and indirect dependencies, and includes context such as the source file path (or image reference for container images) and runtime/development scope, enabling integration with GitHub's dependency graph.
pkg/report/github · high confidence
Add Go binary dependency analyzer
Introduces a new analyzer for the \gobinary\ language type that scans executable Go binaries to detect their embedded dependencies. The analyzer registers with the fanal framework, identifies executable files, and delegates parsing to the existing Go binary parser to extract package information, including standard library versions and third-party module dependencies.
pkg/fanal/analyzer/language/golang/binary · high confidence
Add Julia dependency manifest parser
Trivy now supports analyzing Julia projects by parsing \Manifest.toml\ files to detect installed packages and their dependency trees. The new parser in \pkg/dependency/parser/julia/manifest\ handles both legacy (v1.0) and modern (v2.0) manifest formats, correctly extracting package names, versions, UUIDs, and dependency relationships. It also provides source location information (line numbers) for each detected package and includes comprehensive test coverage for various manifest structures, including edge cases like shadowed dependencies and missing child dependencies.
pkg/dependency/parser/julia · high confidence
Add Julia language dependency analysis
The tool now analyzes Julia projects by parsing \Manifest.toml\ and \Project.toml\ files to identify installed packages. It distinguishes between direct and indirect dependencies, correctly flags development dependencies, and handles Julia 1.9 features such as package extensions and weak dependencies.
pkg/fanal/analyzer/language/julia · high confidence
Add NuGet dependency parsers for packages.config, packages.props, and packages.lock.json
The NuGet dependency parser now supports three additional file formats: \packages.config\ (XML), \packages.props\ (MSBuild props files), and \packages.lock.json\ (NuGet lock files). Parsing \packages.config\ extracts package IDs and versions while skipping development dependencies. Parsing \packages.props\ handles both \PackageReference\ and \PackageVersion\ entries, preferring the \Include\ attribute over the legacy \Update\ attribute, and skips entries containing unresolved variables. Parsing \packages.lock.json\ resolves direct and transitive dependencies, correctly identifying project references to skip them, and captures dependency relationships and source locations for both simple and multi-targeting scenarios.
pkg/dependency/parser/nuget · high confidence
Add Pipenv lock file parser
Users can now have their Python dependencies detected when using Pipenv, as a new parser has been added to read and extract package information from Pipfile.lock files.
pkg/dependency/parser/python/pipenv · high confidence
Add Python pyproject.toml dependency parser with Poetry v2 and normalization support
A new parser for Python \pyproject.toml\ files has been added to the dependency scanning engine. It supports both standard PEP 621 \project.dependencies\ and legacy \tool.poetry.dependencies\ formats, including full support for Poetry v2's list-based dependency syntax. The parser normalizes package names according to PEP 503 to ensure consistent matching and correctly handles optional dependencies and empty dependency entries without panicking.
pkg/dependency/parser/python/pyproject · high confidence
Add RapidFort curated image vulnerability scanning
Users can now detect vulnerabilities in container images built by RapidFort. This change introduces a new scanner in the OS package detector that recognizes images marked with the RapidFort supplier and queries the RapidFort security advisories database. It supports Ubuntu, Debian, Alpine, Red Hat, Oracle Linux, Rocky, Alma, and Amazon Linux, correctly routing packages to the appropriate advisory buckets and handling RapidFort-specific rebuild markers.
pkg/detector/ospkg/rapidfort · high confidence
Add Root.io vulnerability scanning support for Debian, Ubuntu, and Alpine
This change introduces a new vulnerability scanner for Root.io, a security patch provider for Linux distributions. The implementation adds a new \rootio\ package within the OS package detector that automatically activates when it detects Root.io-specific package version patterns (such as \.root.io\ suffixes for Debian/Ubuntu or \-r007\ patterns for Alpine). The scanner integrates with the Trivy database to fetch advisories from the Root.io data source, allowing users to detect vulnerabilities patched by Root.io in addition to those from the base OS distribution. The entry includes the core scanning logic, a supplier mechanism to detect the Root.io environment, and comprehensive test coverage for the new functionality.
pkg/detector/ospkg/rootio · high confidence
Add Ruby Bundler and Gemspec analyzers with checksum support
The fanal analyzer now includes dedicated analyzers for Ruby dependencies, specifically for Bundler (Gemfile.lock) and Gemspec files. The new Bundler analyzer detects Gemfile.lock files to parse Ruby gems, while the Gemspec analyzer identifies .gemspec files in the specifications directory. Additionally, the Gemspec analyzer now supports file checksums (digests) in the analysis results when enabled, allowing for more precise package identification.
pkg/fanal/analyzer/language/ruby · high confidence
Add Ruby Bundler lockfile parser with dependency graph support
The Ruby Bundler dependency parser has been implemented to analyze Gemfile.lock files, extracting package names, versions, and line locations. It distinguishes between direct and indirect dependencies and reconstructs the dependency graph (relationships) from the lockfile's indentation structure, including handling for Bundler 2 formats and malformed inputs.
pkg/dependency/parser/ruby/bundler · high confidence
Add Ruby gemspec dependency parser
Users can now detect Ruby dependencies defined in gemspec files. The new parser extracts the gem name, version, and license information (including multiple licenses) from gemspec specifications, enabling visibility into dependencies that were previously uncovered by the gemfile parser alone.
pkg/dependency/parser/ruby/gemspec · high confidence
Add Rust binary dependency parser for auditable binaries
Users can now detect Rust crates and their versions embedded in compiled binaries that were built with cargo-auditable. This new parser in the \pkg/dependency/parser/rust/binary\ package scans ELF, PE, and Mach-O executables to extract runtime package information and dependency relationships, enabling visibility into dependencies for applications distributed as compiled binaries rather than source code.
pkg/dependency/parser/rust/binary · high confidence
Add SBOM analyzer to detect packages from SPDX and CycloneDX files
A new SBOM analyzer has been added to automatically detect and parse Software Bill of Materials (SBOM) files in SPDX (.spdx, .spdx.json) and CycloneDX (.cdx, .cdx.json) formats. The analyzer integrates these findings into the scan results as packages and applications, ensuring correct file paths are preserved for merging multiple SBOMs and handling Bitnami image components. It also excludes PEP 770 SBOMs located in .dist-info/sboms/ directories to avoid duplication with the Python packaging analyzer.
pkg/fanal/analyzer/sbom · high confidence
Add SPDX SBOM report generation support
Users can now generate Software Bill of Materials (SBOM) reports in SPDX format. This change introduces a new writer component in the report package that marshals internal scan data into SPDX documents, supporting both JSON (formatted with indentation for readability) and Tag-Value output styles via the spdx-tools-golang library.
pkg/report/spdx · high confidence
Add SUSE family vulnerability detection support
The vulnerability detector now supports SUSE Linux Enterprise (SLES), SUSE Linux Enterprise Micro, openSUSE Leap, and openSUSE Tumbleweed. This change introduces a new scanner in \pkg/detector/ospkg/suse\ that queries the SUSE CVRF data source to identify vulnerabilities, including version-aware checks for SLES and openSUSE Leap, while automatically supporting the rolling-release Tumbleweed. End-of-life dates for various SLES, Micro, and openSUSE versions are included to ensure only supported releases are scanned.
pkg/detector/ospkg/suse · high confidence
Add Spring4Shell detection module example
A new example module (\examples/module/spring4shell\) has been added to demonstrate how to build and use WebAssembly-based Trivy modules. This specific module detects the Spring4Shell vulnerability ([CVE redacted]) by analyzing Java and Tomcat version files to adjust the vulnerability severity from CRITICAL to LOW when the environment is not actually affected (e.g., JDK 8). The entry includes the Go source code for the WASM module and a README explaining how to build, install, and run it.
examples/module · high confidence
Add Swift Package.resolved dependency parser
Trivy now supports parsing Swift Package Manager lock files (Package.resolved) to detect dependencies. The new parser handles both version 1 and version 2 of the lock file format, extracting package names and versions from the pinned states. It also supports resolving versions from branch names when explicit version tags are not provided, ensuring broader coverage of Swift project dependencies.
pkg/dependency/parser/swift/swift · high confidence
Add UUIDv7 generation support
The pkg/uuid package now includes a NewV7 function that generates time-ordered UUID version 7 identifiers, in addition to the existing standard UUID generation. This allows users to create UUIDs that are sortable by time, which can improve database performance for ordered data.
pkg/uuid · high confidence
Add Yarn lockfile parser for Node.js dependencies
Introduces a new parser for Yarn lockfiles (both v1 and v2 formats) in the Node.js dependency analysis module. The implementation handles parsing package names, versions, and dependency trees from \yarn.lock\ files, including support for scoped packages, multiple version constraints, and various protocols (npm, git, file, workspace). It also includes test cases and test data to validate the parsing logic against various lockfile structures.
pkg/dependency/parser/nodejs/yarn · high confidence
Add analyzer for detecting Rust dependencies in compiled binaries
Users can now detect Rust library dependencies embedded in compiled executable files. A new analyzer registers for Rust binary files, extracting package names and versions (including dependency relationships) by parsing the binary content, and includes tests for valid Rust binaries, non-Rust executables, and broken ELF files.
pkg/fanal/analyzer/language/rust/binary · high confidence
Add analyzer for unpackaged binaries
A new executable analyzer has been added to the fanal package to detect and analyze binary files that are not managed by package managers. This analyzer calculates the SHA-256 digest for each identified executable, enabling the system to search for SBOM attestations for these unpackaged binaries during the post-analysis phase.
pkg/fanal/analyzer/executable · high confidence
Add bounded read helpers to the io utility package
The pkg/x/io package now includes utilities for controlling read operations: a CountingReader to track bytes read, a MaxBytesReader (and ReadAllWithLimit) to enforce byte limits and return a specific error when exceeded, and a context-aware Copy function that supports cancellation during reads.
pkg/x/io · high confidence
Add clock package for context-based time management
A new \pkg/clock\ package has been introduced to manage time via context values. This allows callers to inject specific times for testing or deterministic behavior using \With\, while \Now\ and \Clock\ functions retrieve the current time from the context, falling back to the real system clock if no time is set.
pkg/clock · high confidence
Add dedicated OS analyzers for AlmaLinux, CentOS, Fedora, Oracle Linux, Rocky Linux, and Debian
The fanal OS detection layer now includes specific analyzers for AlmaLinux, CentOS, Fedora, Oracle Linux, and Rocky Linux, each registering to parse their respective release files (e.g., \etc/almalinux-release\, \etc/centos-release\) to identify the OS family and version. A new Debian analyzer has also been added to detect Debian-based systems via \etc/debian\_version\. These new components replace or supplement the previous generic \redhat-release\ parsing logic, ensuring that distinct distributions are correctly identified rather than falling back to a generic Red Hat base classification.
pkg/fanal/analyzer/os/redhatbase · high confidence
Add example ignore policies including a check whitelist
The examples/ignore-policies directory now includes three Rego policy files: basic.rego, advanced.rego, and whitelist.rego. The basic and advanced examples demonstrate how to ignore vulnerabilities based on package names, severity levels, CVSS vectors (such as requiring high privileges or user interaction), specific CWE IDs, and license rules. The new whitelist.rego example shows how to selectively ignore only specific checks by AVD ID, allowing users to create a whitelist of allowed security checks.
examples/ignore-policies · high confidence
Add generic concurrent-safe Map type
Introduces a new generic \Map\[K, V\]\ type in \pkg/x/sync\ that wraps Go's standard \sync.Map\ to provide type-safe concurrent access. This component exposes standard map operations including \Store\, \Load\, \Delete\, \LoadOrStore\, \LoadAndDelete\, \Range\, and \Len\, allowing users to utilize a thread-safe map with explicit generic type parameters instead of handling \any\ type assertions manually.
pkg/x/sync · high confidence
Add generic string conversion utilities
Introduces new generic helper functions in the strings package to convert slices of various types to string slices and vice versa. The ToStringSlice function handles conversion by checking for string types, fmt.Stringer implementations, or falling back to fmt.Sprint, while ToTSlice provides a direct cast from string slices to typed slices.
pkg/x/strings · high confidence
Add library version comparison logic
Introduces a new \compare\ package in the detector library that provides version comparison capabilities. This includes a \Comparer\ interface and a \GenericComparer\ implementation that checks if a package version is vulnerable based on advisory constraints, handling edge cases like empty versions and invalid constraints.
pkg/detector/library/compare · high confidence
Add parallel execution semaphore with configurable concurrency
A new semaphore package has been introduced to manage parallel execution limits. It wraps the golang.org/x/sync/semaphore library to provide a weighted semaphore, allowing users to control the number of concurrent operations. The implementation defaults to a parallelism of 5 if no specific limit is provided, enabling more predictable resource usage during scanning or other parallel tasks.
pkg/semaphore · high confidence
Add parser for Conda environment metadata
Users can now detect packages installed in Conda environments by parsing the JSON metadata files located in the \conda-meta\ directory. This new parser extracts the package name, version, and license information from these files, enabling Trivy to include Conda-managed dependencies in its vulnerability and license scans.
pkg/dependency/parser/conda/meta · high confidence
Add parser for Elixir Mix lock files
Users can now have Elixir dependencies detected via the \mix.lock\ file. This change introduces a new parser in the Hex ecosystem that extracts package names and versions from the lock file, including support for tracking source locations. Git-based dependencies are currently skipped, and malformed entries without version fields are handled gracefully with warnings.
pkg/dependency/parser/hex · high confidence
Add parser for Gradle lockfiles with dev-dependency detection
A new parser has been added for Gradle lockfiles (e.g., \gradle.lockfile\) that extracts dependency names, versions, and line locations. The parser distinguishes between production and development dependencies by analyzing the \classPaths\ field; dependencies associated exclusively with test configurations (those with class paths starting with "test") are marked as development dependencies, while others are treated as production dependencies.
pkg/dependency/parser/gradle · high confidence
Add pnpm lock file analysis with license detection
The pnpm analyzer now parses pnpm-lock.yaml files to detect Node.js packages and their licenses. It specifically handles pnpm's snapshot-based package IDs by mapping them to standard dependency IDs for license matching, and includes tests for various scenarios including direct and indirect dependencies.
pkg/fanal/analyzer/language/nodejs/pnpm · high confidence
Add registry authentication commands
Users can now authenticate with and log out from container registries using the new \trivy auth\ CLI commands. The \Login\ function validates provided credentials against the target registry and stores them in the Docker configuration file, while \Logout\ removes the stored credentials for a specified registry.
pkg/commands/auth · high confidence
Add support for Amazon Linux 2023 vulnerability scanning
The Amazon Linux OS package detector now supports vulnerability scanning for Amazon Linux 2023. The scanner recognizes the 2023 version string, applies an end-of-life date of March 15, 2028, and queries the vulnerability database for advisories specific to this release. This change extends the existing support for Amazon Linux 1 and 2, ensuring that packages on AL2023 are correctly matched against security fixes.
pkg/detector/ospkg/amazon · high confidence
Add support for Conda environment files with license detection
The analyzer now detects and parses \environment.yml\ and \environment.yaml\ files. In addition to listing installed packages, it automatically resolves and includes license information for each package by reading the corresponding metadata JSON files from the \conda-meta\ directory, enabling users to see license compliance details for their Conda environments.
pkg/fanal/analyzer/language/conda/environment · high confidence
Add support for Cosign vulnerability attestation predicates
Users can now generate vulnerability scan results in the Cosign predicate format, enabling integration with Sigstore/Cosign workflows. The new \pkg/report/predicate\ package introduces a \VulnWriter\ that serializes Trivy scan reports into a \CosignVulnPredicate\ JSON structure, including scanner metadata (URI, version), database details, and scan timestamps.
pkg/report/predicate · high confidence
Add support for Google Container Registry and Artifact Registry authentication
Users can now authenticate to Google Container Registry (gcr.io) and Google Artifact Registry (-docker.pkg.dev) when pulling images. The new registry client supports custom GCP credential paths via the GCPCredPath option and automatically handles default credential stores. It also explicitly skips authentication for mirror.gcr.io to prevent errors when downloading databases.
pkg/fanal/image/registry/google · high confidence
Add support for analyzing .NET Packages.props files
The analyzer now detects and parses NuGet package versions from .NET \Packages.props\ and \Directory.Packages.props\ files. This enables the tool to identify dependencies defined in these centralized package versioning files, including support for lowercase filenames, thereby improving visibility into .NET project dependency trees.
pkg/fanal/analyzer/language/dotnet/packagesprops · high confidence
Add support for analyzing Elixir mix.lock files
The analyzer now detects and parses Elixir \mix.lock\ files to identify Hex package dependencies. This new capability allows users to see the specific versions of locked dependencies in their Elixir projects, improving dependency visibility and security scanning accuracy for Elixir-based applications.
pkg/fanal/analyzer/language/elixir · high confidence
Add support for analyzing Gradle lockfiles with license and dependency graph enrichment
The Gradle analyzer now processes \gradle.lockfile\ files to detect dependencies, enriching the results with license information and dependency relationships by cross-referencing the local Gradle cache POM files. This allows users to see not just which libraries are locked, but also their specific licenses and which other packages they depend on, providing a more complete view of the project's supply chain.
pkg/fanal/analyzer/language/java/gradle · high confidence
Add support for analyzing Python projects managed by uv
The Python analyzer now detects and parses \uv.lock\ files generated by the uv package manager. This change introduces a new post-analyzer that scans for \uv.lock\ files, extracts the dependency tree (including dev dependencies and indirect packages), and reports them as standard Python application packages, enabling vulnerability scanning for projects using uv instead of or alongside pip/poetry.
pkg/fanal/analyzer/language/python/uv · high confidence
Add support for analyzing Swift Package.resolved lock files
The Swift language analyzer now detects and parses Package.resolved files, allowing users to identify specific versions of Swift dependencies resolved by the Swift Package Manager. This new capability ensures that Swift projects using the standard lock file format are fully covered during vulnerability scanning.
pkg/fanal/analyzer/language/swift/swift · high confidence
Add support for parsing Conan v2.x lockfiles
The C dependency parser now recognizes and parses Conan v2.x lockfiles (version 0.5 format) in addition to the existing v1.x support. When a \conan.lock\ file is encountered, the parser automatically detects the format: if the \graph\_lock\ field is present, it processes the v1.x graph structure; otherwise, it treats the file as v2.x, extracting direct dependencies from the \requires\ array. This ensures that projects using the newer Conan package manager version are correctly scanned for vulnerabilities.
pkg/dependency/parser/c · high confidence
Add support for parsing Conda environment.yml files
Users can now have their Conda \environment.yml\ files analyzed for dependencies. This new parser extracts package names and pinned versions from standard dependency lists, including those managed via \pip\ within the environment file, and reports the Conda environment prefix. It handles various version specification formats (e.g., \==\, \\>=\) and gracefully skips unpinned dependencies or malformed entries.
pkg/dependency/parser/conda/environment · high confidence
Add support for parsing Poetry v2 lockfiles
The Poetry dependency parser now supports the new lockfile format introduced in Poetry v2. This change updates the parser to handle the structural differences between Poetry v1 and v2 lockfiles, specifically the shift from the \category\ field to the \groups\ field for identifying development dependencies. The implementation includes logic to correctly identify dev dependencies based on group membership (e.g., \groups = \["dev"\]\) and ensures that package name normalization is applied consistently when matching dependencies against installed versions.
pkg/dependency/parser/python/poetry · high confidence
Add support for parsing SBT dependency lock files
Users can now analyze SBT projects that use the sbt-dependency-lock plugin. A new parser in the SBT dependency parser module reads the lockfile format (version 1), extracting library coordinates and versions for dependencies in the 'compile' and 'runtime' configurations, enabling vulnerability detection for these locked dependencies.
pkg/dependency/parser/sbt · high confidence
Add support for parsing pylock.toml (PEP 751) dependency files
Users can now have their Python dependency lockfiles generated by \pip lock\ (following PEP 751) automatically detected and parsed. This new parser in the \pylock\ module reads \pylock.toml\ files to extract package names, versions, and dependency relationships, enabling vulnerability scanning for projects using this modern lockfile format alongside existing ones like \requirements.txt\ or \poetry.lock\.
pkg/dependency/parser/python/pylock · high confidence
Add support for parsing uv lockfiles
Users can now scan Python projects managed by the uv package manager. This change introduces a new parser in \pkg/dependency/parser/python/uv\ that reads \uv.lock\ files, correctly identifying production versus dev dependencies, handling optional dependency groups, and supporting both standard projects and uv workspaces (including those with and without a root package).
pkg/dependency/parser/nodejs/bun, pkg/dependency/parser/python/uv · high confidence
Add support for scanning virtual machine disk images
Users can now scan virtual machine disk images (specifically VMDK) by introducing a new disk parsing layer in \pkg/fanal/vm/disk\ and filesystem handlers for EXT4 and XFS in \pkg/fanal/vm/filesystem\. The implementation detects the disk format, opens the VMDK file using the \go-vmdk-parser\ library, and then iterates through supported filesystem types to provide a unified filesystem view for analysis, backed by an LRU cache for performance.
pkg/fanal/vm · high confidence
Add vulnerability detection for Azure Linux and CBL-Mariner
Users can now detect vulnerabilities in packages installed on Azure Linux and CBL-Mariner operating systems. This change introduces a new detector in \pkg/detector/ospkg/azure\ that queries the Trivy database for advisories specific to these distributions, correctly handling source package names and version comparisons to identify both patched and unpatched vulnerabilities.
pkg/detector/ospkg/azure · high confidence
Add vulnerability detection for MinimOS
Users can now detect vulnerabilities in MinimOS packages. This change introduces a new scanner in the OS package detector that queries the MinimOS security database (MinimOS Secdb) to identify affected packages and their fixed versions, including support for parsing complex version strings like release candidates and pre-releases.
pkg/detector/ospkg/minimos · high confidence
Add vulnerability detection for Rocky Linux
Users can now detect vulnerabilities in packages installed on Rocky Linux operating systems. This change introduces a new scanner in the OS package detector that queries the vulnerability database for Rocky Linux advisories, supporting both standard and modular packages (via namespace handling) and specific architectures. It also enforces end-of-life checks for Rocky Linux 8 (EOL May 2029) and Rocky Linux 9 (EOL May 2032), ensuring unsupported versions are flagged.
pkg/detector/ospkg/oracle, pkg/detector/ospkg/rocky · high confidence
Add vulnerability detection support for Wolfi Linux
Users can now detect vulnerabilities in packages installed on Wolfi Linux distributions. This change introduces a new scanner implementation in \pkg/detector/ospkg/wolfi\ that queries the Wolfi Secdb (https://packages.wolfi.dev/os/security.json) to identify affected packages and their fixed versions, mirroring the recently added support for Chainguard.
pkg/detector/ospkg/wolfi · high confidence
Add vulnerability detection support for the Echo rolling distribution
Users can now detect vulnerabilities in packages installed on the Echo Linux distribution. This change introduces a new OS detector that queries the Echo advisory feed, correctly handling Echo's rolling-release model by skipping OS-version checks and using source package names and versions for matching. The implementation includes the scanner logic and associated test fixtures to validate vulnerability detection against the Echo data source.
pkg/detector/ospkg/echo · high confidence
Add vulnerability scanning support for AlmaLinux
Users can now detect vulnerabilities in packages installed on AlmaLinux systems. This change introduces a new scanner that queries the Trivy database for AlmaLinux-specific advisories, supporting versions 8, 9, and 10 with their respective end-of-life dates. The scanner correctly handles modular packages by applying namespace prefixes based on the modularity label, while explicitly skipping modular packages where the modularity label is missing to avoid incorrect detection due to known AlmaLinux bugs.
pkg/detector/ospkg/alma · high confidence
Add vulnerability scanning support for Photon OS
Users can now detect vulnerabilities in Photon OS packages. This change introduces a new scanner implementation in \pkg/detector/ospkg/photon\ that queries the vulnerability database for Photon-specific advisories, compares installed package versions against fixed versions, and reports detected vulnerabilities. It also includes end-of-life (EOL) checks for Photon OS versions 1.0 through 5.0 to ensure only supported versions are scanned.
pkg/detector/ospkg/photon · high confidence
Add vulnerability scanning support for Seal packages
Users can now detect vulnerabilities in packages provided by the Seal security feed. This change introduces a new scanner in the OS package detector that identifies packages with the 'seal' prefix (in name or source name) across supported distributions (Alpine, Debian, Ubuntu, Red Hat, CentOS, CBL-Mariner, and Oracle). These packages are scanned against the Seal Security Database, while other packages continue to be scanned by their respective base OS scanners.
pkg/detector/ospkg/seal · high confidence
Add xslices utility functions for slice transformation and normalization
The pkg/x/slices package now provides two new utility functions: Map, which transforms a slice without passing an index to the callback (replacing lo.Map usage), and ZeroToNil, which converts empty slices to nil for consistent nil-checking behavior.
pkg/x/slices · high confidence
Added ARM adapter for Azure Authorization resources
The system now adapts Azure ARM templates containing Microsoft.Authorization/roleDefinitions and Microsoft.Authorization/roleAssignments resources. This allows the scanner to extract and evaluate role definitions (including permissions and assignable scopes) and role assignments (including principal IDs and types) from Infrastructure-as-Code deployments.
pkg/iac/adapters/arm/authorization · high confidence
Added Alpine Linux OS detection analyzer
The system now includes a dedicated analyzer for detecting Alpine Linux operating systems. This new component registers an analyzer that identifies Alpine by checking for the presence of the \/etc/alpine-release\ file and extracts the version number from its content, enabling accurate OS family identification for Alpine-based containers.
pkg/fanal/analyzer/os/alpine · high confidence
Added Go-based WebAssembly SDK for module communication
The \pkg/module/wasm\ package now includes a new \sdk.go\ file that provides the runtime support for Go-written WebAssembly modules. This SDK implements the necessary memory management (malloc/free) and marshaling (JSON serialization/deserialization) to allow modules to communicate with the host application via WASI imports and exports, enabling features like logging, module registration, and analysis execution within the WASM environment.
pkg/module/wasm · high confidence
Added Google Cloud Storage bucket adapter with logging and versioning support
The adapter for Google Cloud Storage buckets now extracts logging and versioning configurations from Terraform resources. Specifically, it maps the \log\_bucket\ and \log\_object\_prefix\ attributes for access logging, as well as the \enabled\ flag for versioning, into the internal storage model. This ensures that security checks and compliance scans can evaluate these settings on GCS buckets.
pkg/iac/adapters/terraform/google/storage · high confidence
Added Google KMS adapter to parse crypto key rotation periods
The new adapter in \pkg/iac/adapters/terraform/google/kms\ enables the system to ingest Google Cloud KMS configurations, specifically extracting \google\_kms\_key\_ring\ and \google\_kms\_crypto\_key\ resources. It now correctly parses the \rotation\_period\ attribute from Terraform definitions (e.g., "7776000s") into a numeric seconds value for security assessments, defaulting to -1 if the period is missing, invalid, or not specified.
pkg/iac/adapters/terraform/google/kms · high confidence
Added JSON-serializable image reference type
The \pkg/fanal/image/name\ package now includes a \Reference\ type that wraps the underlying container image reference to support JSON marshaling and unmarshaling. This allows image references to be directly included in JSON reports and metadata, ensuring they are correctly serialized as strings and deserialized back into structured objects, with support for empty references and digest-based identifiers.
pkg/fanal/image/name · high confidence
Added Pipenv lock file analyzer
The system now includes a dedicated analyzer for Pipenv, enabling the detection and parsing of Python dependencies defined in Pipfile.lock. This new component registers with the analysis framework to identify Pipfile.lock files and delegates parsing to the internal Pipenv parser, allowing users to view their Pipenv-managed library versions in scan results.
pkg/fanal/analyzer/language/python/pipenv · high confidence
Added Red Hat buildinfo analyzers for content manifests and Dockerfiles
The buildinfo analyzer now includes two new components: a content manifest analyzer that extracts Red Hat content sets from JSON files in \root/buildinfo/content\_manifests/\ and \usr/share/buildinfo/\, and a Dockerfile analyzer that parses Dockerfiles in \root/buildinfo/\ to extract component names and architecture from specific Red Hat labels. These additions enable more detailed build information extraction for Red Hat-based images.
pkg/fanal/analyzer/buildinfo · high confidence
Added Terraform adapters for CloudStack, Google BigQuery, Google DNS, and OpenStack
Trivy now supports scanning Terraform configurations for CloudStack, Google BigQuery, Google DNS, and OpenStack. New adapter implementations parse CloudStack instances (including base64-decoded user data), Google BigQuery dataset access grants, Google DNS managed zones with DNSSEC configurations, and OpenStack compute instances, firewall rules, and security groups, enabling security checks against these specific cloud providers.
(repo-wide) · high confidence
Added common port range parsing utility for network adapters
Introduced a new \ParsePortRange\ function in the common network adapter package to standardize how port specifications are interpreted. This utility handles single ports, hyphenated ranges (e.g., \1000-2000\), and optional wildcard support (\\*\), while correctly handling whitespace and returning invalid states for malformed inputs. This change provides a robust foundation for network rule parsing across adapters, such as the Google Compute Firewall adapter, ensuring consistent behavior for port range validation.
pkg/iac/adapters/common · high confidence
Added local authentication server configuration and TLS certificates
Integration test data now includes a local authentication server configuration (config.yml) defining users, ACLs, and token settings, along with the corresponding self-signed TLS certificate and private key files. This enables testing of authenticated registry interactions using the provided credentials.
integration/data · high confidence
Added path utility to detect subpath components
Introduced a new \Contains\ function in the \pkg/x/path\ package that checks if a file path string contains a specific subpath component by splitting on slashes. This utility supports use cases such as identifying whether a path includes specific directories like \node\_modules\, as demonstrated by the accompanying test cases.
pkg/x/path · high confidence
Alpine Linux vulnerability scanner implementation and EOL support
The Alpine OS package detector now includes a dedicated scanner that resolves vulnerabilities using source package names (falling back to binary names if source names are missing) and supports advisory data for both fixed and unfixed vulnerabilities. The implementation adds End-of-Life (EOL) date tracking for Alpine versions ranging from 2.0 through 3.23, ensuring that unsupported versions are correctly identified. Additionally, the scanner handles repository release detection, preferring the repository release over the OS version when they differ, and includes logic to warn when mixing Alpine versions.
pkg/detector/ospkg/alpine · high confidence
Automated backporting script for GitHub PRs
A new shell script (misc/backport/backport.sh) has been added to automate the process of backporting pull requests to specific branches. The script accepts a target branch and PR number, fetches the merge commit, creates a new branch, and attempts to cherry-pick the changes. If conflicts arise, it force-commits the conflicting files and updates the PR description with a warning for manual review, then creates a new pull request with appropriate labels and comments.
misc/backport · high confidence
Automated deployment scripts for DEB and RPM package repositories
New CI scripts (\deploy-deb.sh\ and \deploy-rpm.sh\) have been added to automate the publishing of Trivy packages to the official repository. The DEB script handles updates for Debian, Ubuntu (including ESM versions), and a generic release across i386, amd64, and arm64 architectures. The RPM script manages repository updates for RHEL/CentOS versions 5 through 9 on x86\_64 and aarch64 architectures, ensuring that new releases are correctly indexed and old packages are cleaned up.
ci · high confidence
Automated generation of Trivy configuration documentation and JSON Schema
The magefiles build system now includes a new \docs\ command that automatically generates the Trivy configuration reference documentation and a JSON Schema for the \trivy.yaml\ file. This tool scans the application's CLI flags to produce a Markdown reference guide and a \schema/trivy-config.json\ file, ensuring that documentation and schema validation rules stay synchronized with the actual configuration options available to users.
magefiles · high confidence
Azure ACR authentication now supports Azure China Cloud
The Azure registry client has been updated to recognize and correctly configure authentication for Azure China Cloud registries (domains ending in .azurecr.cn). In addition to the existing support for Azure Public Cloud (.azurecr.io), the client now applies the specific Azure China cloud configuration and scope (https://management.chinacloudapi.cn/.default) when a China domain is detected, ensuring valid token acquisition for users operating in that region.
pkg/fanal/image/registry/azure · high confidence
Centralized download and initialization logic for DB, VEX, and policy bundles
The \pkg/commands/operation\ package introduces a unified set of functions to manage the lifecycle of Trivy's data assets. \DownloadDB\ now handles vulnerability database updates with support for multiple OCI repositories and ensures thread-safe execution via a mutex. \DownloadVEXRepositories\ adds the capability to fetch VEX (Vulnerability Exploitability eXchange) data from configured repositories, respecting skip flags. \InitBuiltinChecks\ centralizes the logic for downloading and caching misconfiguration policy bundles, handling updates and cache validation. Finally, the \Exit\ function allows users to configure custom exit codes for End-of-Life (EOL) operating systems and general scan failures, providing finer control over CI/CD pipeline behavior.
pkg/commands/operation · high confidence
CloudFormation intrinsic function resolution and type inference
The CloudFormation parser now resolves intrinsic functions (such as Fn::And, Fn::Base64, Fn::Cidr, Fn::Equals, Fn::FindInMap, Fn::GetAtt, Fn::If, Fn::Join, Fn::Length, Fn::Not, Fn::Or, Fn::Ref, Fn::Select, Fn::Split, and Fn::Sub) to their concrete values during template parsing. This enables the scanner to evaluate conditional logic, perform string manipulation, and resolve resource references statically, ensuring that security checks are applied against the actual resolved configuration rather than unresolved template syntax.
pkg/iac/scanners/cloudformation/parser · high confidence
Conan lock file analysis now includes dependency locations and license information
The C language analyzer now processes Conan lock files (conan.lock and release.lock) to report not only package names and versions, but also the specific line locations where each dependency is declared. Additionally, the analyzer scans the Conan cache directory (supporting both v1 and v2 cache structures) to extract and attach license information to the detected packages, providing a more complete view of dependencies and their licensing.
pkg/fanal/analyzer/language/c · high confidence
Dart analyzer now resolves dependency relationships from pubspec.lock
The Dart language analyzer in the fanal package now supports analyzing \pubspec.lock\ files to detect direct and indirect dependencies. By reading the system cache (via \PUB\_CACHE\ or default locations), the analyzer populates \DependsOn\ fields in the resulting package list, allowing users to see the full dependency graph rather than just a flat list of packages.
pkg/fanal/analyzer/language/dart · high confidence
Detect Echo-patched Python, Maven, and npm packages
The library detector now identifies packages patched by the Echo security initiative by recognizing the "+echo.N" version segment in Python (pip), Java (Maven), and JavaScript (npm) packages. This new supplier registers with the library detection system, using custom comparers for pip and npm to ensure the local version/build metadata is treated significantly during vulnerability matching, allowing users to detect vulnerabilities in these specific patched versions. Also in this area: 1 commit (0 fixes) modifying pkg.
pkg/detector/library/echo · medium confidence · unverified
Detect secrets in container image configuration files
Users can now detect secrets (such as GitHub Personal Access Tokens) embedded in container image configuration files. A new analyzer registers for image config analysis, marshals the config to JSON, and scans it using the existing secret scanner to report findings with file paths, line numbers, and severity levels.
pkg/fanal/analyzer/imgconf/secret · high confidence
Enhanced PHP Composer analysis with dev dependencies, direct/indirect relationships, and installed.json support
The PHP Composer analyzer now distinguishes between direct and indirect dependencies by parsing \composer.json\ alongside \composer.lock\, and it correctly identifies packages listed under \require-dev\ as direct dependencies. It also adds support for analyzing \installed.json\ files found in the \vendor\ directory to capture installed packages. Additionally, the analyzer now skips \composer.lock\ files located inside the \vendor\ folder to avoid duplicate or incorrect analysis.
pkg/fanal/analyzer/language/php · high confidence
Enhanced scan result display with syntax highlighting and cause context
The scan output now provides richer context for failed checks by including syntax-highlighted code snippets and clearly marking the specific lines that caused the failure. This is achieved through new internal components in \pkg/iac/scan\ that handle code extraction, ANSI-based syntax highlighting (supporting themes like Solarized and GitHub), and logic to identify and mark the first and last lines of a multi-line cause. Additionally, the \Rule\ struct now supports \MinimumTrivyVersion\ constraints, deprecation flags, and example fields, while the \FlatResult\ serialization includes a \RenderedCause\ field to carry this enhanced context to users.
pkg/iac/scan · high confidence
Git repository metadata and caching for local filesystem scans
When scanning a local directory, Trivy now detects if it is a Git repository and extracts metadata (commit hash, branch, tags, and remote URL) to include in the scan report. For clean repositories, the cache key is derived from the commit hash, enabling faster subsequent scans by reusing cached results.
pkg/fanal/artifact/local · high confidence
Git test server now supports HTTP basic authentication
The internal git test server (internal/gittest) has been updated to support HTTP basic authentication. Tests can now configure a username and password via the Options struct, which is enforced by the underlying gitkit service and passed to git clone operations. This allows test suites to verify behavior when interacting with protected git repositories.
internal/gittest · high confidence
Helm parser now supports API versions and Kubernetes version configuration
The Helm parser now accepts explicit API versions and Kubernetes version settings via new configuration options (SetAPIVersions and SetKubeVersion). This allows users to control which Kubernetes API versions are available during template rendering, enabling correct rendering of resources like PodDisruptionBudgets that depend on specific API versions (e.g., policy/v1 vs policy/v1beta1) or cluster version constraints.
pkg/iac/scanners/helm/parser · high confidence
Helm scanner now supports API and Kubernetes version configuration
The Helm scanner in \pkg/iac/scanners/helm\ has been updated to allow users to specify the Helm API version and Kubernetes version used during chart rendering. New options (\ScannerWithAPIVersions\ and \ScannerWithKubeVersion\) are available in \options.go\ to pass these values to the underlying Helm parser, enabling more accurate scanning of charts that rely on specific version features or deprecations.
pkg/iac/scanners/helm · high confidence
Initial CloudFormation adapter for AWS resources
The CloudFormation scanner now supports adapting a wide range of AWS resource types into the internal IaC model, enabling security checks on CloudFormation templates. This change introduces adapters for AWS Access Analyzer, API Gateway (v1 and v2), Athena, CloudFront (including v2 logging support), CloudTrail, CloudWatch, CodeBuild, Config, DocumentDB, DynamoDB (including DAX clusters), and EC2 (including VPCs, Security Groups, and Instance MetadataOptions). The \pkg/iac/adapters/cloudformation/aws/adapt.go\ file serves as the central entry point, wiring these individual service adapters together.
pkg/iac/adapters/cloudformation/aws · high confidence
Initial Helm chart for Trivy Server mode
This change introduces the initial Helm chart templates for deploying Trivy in server mode. The chart includes a StatefulSet for the main application, a Service with configurable port and session affinity, and an Ingress resource that supports both networking.k8s.io/v1 and v1beta1 API versions. It also provisions a ConfigMap for environment variables (including Redis cache, proxy, and SSL settings), a Secret for GitHub and Trivy tokens, and RBAC resources (ServiceAccount, Role, RoleBinding) with optional PodSecurityPolicy support. Users can now install and manage a Trivy server instance via Helm, with support for custom labels, pod annotations, node selectors, and image pull secrets.
helm/trivy/templates · high confidence
Initial release of Trivy report templates and CI integration scripts
This change introduces the first set of contrib artifacts for Trivy, providing ready-to-use templates for generating reports in various formats (ASFF, GitLab Container Scanning, GitLab Code Quality, HTML, and JUnit) and an install script for downloading the Trivy binary. Users can now integrate Trivy into their CI/CD pipelines (specifically GitLab CI via the provided YAML template) and export findings to AWS Security Hub, GitLab, or standard JUnit/HTML reports.
contrib · high confidence
Initial release of the Trivy standalone Helm chart
This change introduces the first version of the Trivy Helm chart (chart version 0.26.0, bundling Trivy app version 0.74.0), enabling users to deploy the Trivy vulnerability scanner as a standalone service on Kubernetes. The chart provides configurable options for image settings, persistence, resource limits, and pod scheduling (nodeSelector, affinity, tolerations). It supports advanced features such as Redis-based caching, custom SSL certificate directories, HTTP/HTTPS proxy configuration, and authentication via GitHub tokens or existing secrets for private registries and server access.
helm/trivy · high confidence
Initial support for scanning Ansible playbooks
Users can now scan Ansible playbooks for infrastructure-as-code issues. This change introduces the initial adapter implementation in pkg/iac/adapters/ansible, which parses Ansible tasks and maps them to the internal state model. Currently, the adapter supports scanning AWS S3 bucket configurations (including encryption, public access blocks, and versioning) defined via the s3\_bucket module, with a TODO indicating that other AWS services and S3 features like logging and website configuration are not yet fully implemented.
pkg/iac/adapters/ansible · high confidence
Initial support for scanning Ansible playbooks and inventories
Adds the ability to scan Ansible projects, including the parsing of YAML and INI inventory files, resolution of host and group variables according to Ansible precedence rules, and the discovery of playbook files within project directories.
pkg/iac/scanners/ansible · high confidence
Introduce RPC Cache and Scanner services with updated protocol buffers
This change adds the generated Go code and protocol buffer definitions for the new \Cache\ and \Scanner\ RPC services. The \Cache\ service exposes methods to manage artifact and blob data, including storing artifact metadata (such as OS, architecture, and history packages) and blob details (including packages, applications, misconfigurations, secrets, and licenses). The \Scanner\ service provides a \Scan\ RPC that accepts scan targets and options, allowing clients to specify package types, scanners to run, license categories, and whether to include development dependencies. These definitions establish the contract for client-server communication in the scanning workflow.
rpc · high confidence
Introduce RPC client for remote scanning with server version integration
Added a new RPC client implementation in \pkg/rpc/client\ that enables Trivy to operate in client/server mode. This client supports custom HTTP headers for authentication, configurable path prefixes for proxying, and automatically fetches and includes server version information in scan responses. It also maps scan options such as package types, relationships, and distribution details to the remote scanner.
pkg/rpc/client · high confidence
Introduce Rego schema definitions and builder for IaC analysis
The \pkg/iac/rego/schemas\ package now provides the foundational schema definitions and a Go-based builder used to generate JSON schemas for Rego policy evaluation. This includes static schema files for Dockerfile, Kubernetes, RBAC, and raw Terraform configurations, alongside a dynamic \cloud.json\ schema generated from the internal \state.State\ struct to cover AWS, Azure, Google, and other cloud providers. The \builder.go\ component reflects on the internal types to construct these schemas, enabling Rego policies to validate and query Infrastructure-as-Code structures with accurate type information.
pkg/iac/rego/schemas · high confidence
Introduce Rekor client with UUID-only ID parsing and SBOM attestation extraction
Added a new Rekor client in pkg/rekor that supports parsing entry IDs consisting solely of a UUID (in addition to the standard TreeID+UUID format) and extracts SBOM attestation data from log entries. The client also sets a custom User-Agent header on requests and enforces a bulk retrieval limit of 10 entries to prevent excessive API usage.
pkg/rekor · high confidence
Introduce SPDX SBOM marshaler and unmarshaler with comprehensive test coverage
Added the SPDX SBOM encoder and decoder implementations in the \pkg/sbom/spdx\ package, enabling Trivy to generate and parse SPDX-format Software Bill of Materials reports. The new \Marshaler\ converts internal BOM data into SPDX documents, handling package metadata, license normalization, and relationships, while the \Unmarshaler\ reconstructs the internal BOM from SPDX JSON and tag-value inputs. This change is accompanied by extensive test suites (\marshal\_test.go\, \unmarshal\_test.go\) and test fixtures covering happy paths, edge cases like null entries and invalid PURLs, and specific SPDX features such as file checksums and package purposes.
pkg/sbom/spdx · high confidence
Introduce Trivy RPC server with client/server mode support
This change introduces the core RPC server implementation in \pkg/rpc/server\, enabling Trivy to operate in a client/server architecture. The new \listen.go\ and \server.go\ files define the HTTP server that exposes Twirp-based scan and cache services, supporting features such as token-based authentication, gzip compression, a configurable path prefix, and a health check endpoint. It also includes a background worker for automatic vulnerability database updates and exposes server version information via a JSON endpoint, allowing clients to offload scanning work to a dedicated server instance.
pkg/rpc/server · high confidence
Introduce VEX repository management with path traversal protection
This change adds a new VEX repository manager in pkg/vex/repo that allows users to configure, list, and download external VEX repositories. The manager handles repository configuration via a YAML file, supports per-repository TLS verification settings, and includes a security fix that rejects repository names containing path traversal sequences (such as "../" or absolute paths) to prevent directory escape during cache operations.
pkg/vex/repo · high confidence
Introduce centralized HTTP transport with request tracing and redaction
The HTTP client layer has been refactored to use a centralized transport configuration in \pkg/x/http\. Users can now enable HTTP request and response tracing via the \TraceHTTP\ option, which automatically logs requests and responses to stderr while redacting sensitive headers (such as Authorization and Cookies), query parameters, and body content (including binary data and detected secrets like private keys). The transport also supports custom proxy functions, configurable timeouts, and custom CA certificates, providing a unified way to manage HTTP settings across the application.
pkg/x/http · high confidence
Introduce cryptographic asset analysis with built-in security checks
The \pkg/crypto\ package now provides a comprehensive framework for analyzing cryptographic assets found in scanned images. It introduces a catalog of algorithms (including ML-DSA, Ed25519, and standard RSA/EC/DSA) to describe keys and signatures by their OIDs and parameters. The system automatically assesses nominal classical and NIST post-quantum security levels for these algorithms. Additionally, it includes a built-in rule engine (\pkg/crypto/check\) that evaluates assets against specific security policies, such as flagging SHA-1 signatures, RSA keys smaller than 2048 bits, weak elliptic curves, and expired certificates, reporting these as findings in the scan report.
pkg/crypto · high confidence
Introduce dedicated PURL generation and parsing utilities
This change introduces a new \pkg/purl\ package that centralizes the creation and parsing of Package URLs (PURLs) for detected software components. It provides a \New\ function that constructs PURLs from internal package metadata, handling specific logic for various ecosystems such as RPM, Debian, Alpine, Maven, Gradle, PyPI, Composer, Go, NPM, Swift, and Kubernetes. The implementation also includes a \LangType\ method to map PURL types back to Trivy's internal language types, ensuring consistent identification across different package managers and operating systems.
pkg/purl · high confidence
Introduce extensible WASM module system for custom analyzers and post-scanners
This change adds a new \pkg/module\ package that enables users to install, load, and execute custom WebAssembly (WASM) modules to extend Trivy's scanning capabilities. The implementation provides a \Manager\ that loads \.wasm\ files from a specified directory, instantiates them using the \wazero\ runtime, and registers their functionality as either \Analyzer\ or \PostScanner\ components within the existing analysis pipeline. Modules can define required file patterns, perform file analysis, or modify scan results (e.g., inserting or updating vulnerabilities) via a \PostScan\ hook. The system supports installing modules from OCI repositories and includes a memory-based file system (\memFS\) to provide isolated file access to the WASM guests.
pkg/module · high confidence
Introduce generic parallel processing pipeline and directory walker
The \pkg/parallel\ package now provides a new generic \Pipeline\ type for executing parallel processing workflows with configurable worker counts and optional progress reporting, alongside a \WalkDir\ function for concurrently walking filesystem directories. These additions replace the previous parallel walk implementation, offering a more flexible and type-safe approach to parallelizing item processing and file system traversal within the application.
pkg/parallel · high confidence
Introduce generic scanner for JSON, YAML, and TOML files
A new generic scanner has been added to the IaC scanning engine, enabling the application of Rego policies to JSON, YAML, and TOML configuration files. This change introduces \NewJsonScanner\, \NewYamlScanner\, and \NewTomlScanner\ constructors that parse these formats and feed the resulting data structures into the Rego engine, allowing users to write unified checks for these common data formats alongside traditional infrastructure-as-code files.
pkg/iac/scanners/generic · high confidence
Introduce in-memory filesystem abstraction
Added a new \pkg/mapfs\ package that provides an in-memory filesystem implementation supporting virtual files, directory operations, and optional access to the underlying local filesystem via an \underlyingRoot\ configuration. This abstraction allows components to interact with file data through a standard \io/fs\ interface without requiring persistent disk storage, facilitating testing and scenarios where files are generated or managed entirely in memory.
pkg/mapfs · high confidence
Introduce inline ignore rule parsing with wildcard and expiry support
Added the \pkg/iac/ignore\ package to parse inline ignore rules (e.g., \\#trivy:ignore:rule-id\) directly from source files. This new functionality allows users to suppress specific findings using inline comments, supporting wildcard patterns (e.g., \rule-\*\) for flexible ID matching and optional expiry dates (e.g., \:exp:2026-01-01\) to automatically deactivate rules after a certain time. The implementation handles rule scope via line-range shifting and case-insensitive matching.
pkg/iac/ignore · high confidence
Introduce language-specific package vulnerability scanning service
A new scanner service in pkg/scan/langpkg has been added to detect vulnerabilities in language-specific package ecosystems (Python, Ruby, Node.js, Java, etc.). This service iterates through detected application packages, invokes the library vulnerability detection engine, and returns structured results for each language type, enabling targeted security reporting for language-specific dependencies.
pkg/scan/langpkg · high confidence
Introduce new SBOM decode and encode I/O layer
The \pkg/sbom/io\ package now provides a dedicated I/O layer for SBOM processing, introducing a \Decoder\ to parse SBOM files into an internal intermediate representation and an \Encoder\ to serialize reports back to SBOM formats. The decoder handles root components, OS and language-specific packages, and dependency graphs, while the encoder supports options like BOM-Ref generation and parent map preservation, and correctly reuses existing BOM structures when scanning SBOM files to refresh vulnerabilities.
pkg/sbom/io · high confidence
Introduce plugin management with a central index
Users can now install, run, and manage external plugins. The system includes a plugin manager that handles installation from Git repositories, local paths, and HTTP archives (including nested archives), while respecting platform selectors (OS/arch) and custom exit codes. A new plugin index (downloaded from a central URL) enables users to search for available plugins and install them by name, with the manager automatically resolving the repository URL. The implementation adds the \pkg/plugin\ package with core logic for index updates, plugin execution, and metadata handling, along with comprehensive tests for installation, execution, and index search.
pkg/plugin · high confidence
Introduce post-handler execution for analysis results
The fanal package now supports a post-handler mechanism that allows registered handlers to process analysis results after the main analysis phase. Users can register custom post-handlers via \RegisterPostHandlerInit\, which are then executed by the \Manager\ in priority order. This enables extensibility for post-processing tasks, such as modifying blob information or performing additional checks, without altering the core analysis logic.
pkg/fanal/handler · high confidence
Introduce serialization types for module post-scan actions
Added a new \types.go\ file in the \pkg/module/serialize\ package that defines the data structures used for serializing module output. This includes an \AnalysisResult\ struct (currently limited to custom resources) and a \PostScanSpec\ struct, which allows modules to specify post-scan actions such as INSERT, UPDATE, or DELETE for specific vulnerability and misconfiguration IDs.
pkg/module/serialize · high confidence
Introduce server mode with HTTP transport and RPC capabilities
Users can now run Trivy in server mode, which initializes a default HTTP transport (respecting insecure, CA cert, and timeout settings), downloads and initializes the vulnerability database, sets up the cache, and registers WASM modules before starting an RPC server listener. This new \pkg/commands/server/run.go\ entry point enables remote scanning via the RPC server, configurable via options like listen address, token, path prefix, and database repositories.
pkg/commands/server · high confidence
Introduces OS package version comparison and constraint checking
The \pkg/detector/ospkg/version\ package now provides dedicated logic for comparing and validating OS package versions across Debian, Alpine, and Red Hat ecosystems. It introduces specific comparers (\DEBComparer\, \APKComparer\, \RPMComparer\) that utilize external libraries to correctly parse and order complex version strings, including Debian epochs and Alpine revisions. Additionally, a new constraint system allows users to define version ranges (e.g., \\>=1.2.3, \<2.0.0\) using standard operators, which are evaluated against the appropriate package-type comparer to determine if a detected version satisfies the requirement.
pkg/detector/ospkg/version · high confidence
Introduces a unified language analyzer entry point
The \pkg/fanal/analyzer/language\ package now provides a centralized \Analyze\ and \Parse\ interface for processing dependency files. This change consolidates the logic for parsing lock files and package manifests, automatically handling file digests, dependency relationships, and indirect dependency flags, which simplifies the integration of new language parsers into the Trivy analysis pipeline.
pkg/fanal/analyzer/language · high confidence
Introduces cryptographic asset model and parser types
The \pkg/fanal/types\ package now includes a new cryptographic asset model, adding types and constants for identifying and describing certificates, keys, and algorithms. This includes \CryptoKind\, \CryptoDescriptor\ for canonical identity, and specific metadata structs like \CryptoCertificate\ and \CryptoKey\, enabling the system to detect and report cryptographic assets found in scanned artifacts.
pkg/fanal/types · high confidence
Introduces custom registry mirror support and centralized remote image retrieval
The \pkg/remote\ package now provides a new abstraction for interacting with container registries that supports registry mirrors, allowing the system to fall back to configured mirror registries when the primary host is unavailable. This change also centralizes HTTP transport configuration and authentication logic, enabling multiple credential attempts and platform-specific image resolution within a single, unified interface for fetching image descriptors and images.
pkg/remote · high confidence
Introduces ecosystem-specific version comparers and Seal Security supplier support for library vulnerability detection
The library vulnerability detector now uses dedicated version comparers for each ecosystem (Bitnami, Maven, npm, PEP 440/Python, and RubyGems) to ensure advisory constraints are evaluated correctly for each language's versioning rules. Additionally, it adds support for Seal Security as a third-party supplier, allowing Trivy to detect and query Seal-specific patched packages and their advisories via a new supplier registration system.
pkg/detector/library · high confidence
Java POM analyzer now captures dependency relationships, line numbers, and licenses
The new pom.xml analyzer in the fanal package provides richer dependency data for Java projects. It now captures dependency relationships (distinguishing root from direct dependencies), includes source line numbers for each dependency, and extracts license information. Additionally, dependencies from Maven invoker plugin integration test directories are automatically marked as development dependencies to exclude them from default analysis.
pkg/fanal/analyzer/language/java/pom · high confidence
Java POM parsing, cryptographic asset modeling, and Ansible scanning infrastructure
This update introduces three distinct capabilities. First, the Java POM parser now resolves license URLs to SPDX IDs when the license name is missing, correctly inherits properties and versions from parent POMs, and supports the \test\ scope for dependencies. Second, a new cryptographic asset model is added, defining types for certificates, keys, and algorithms with specific identity methods (such as SHA-256 digests) and validation logic. Third, initial infrastructure for Ansible scanning is added, including a \FileSource\ abstraction for handling both virtual and real filesystems and a variable merging system that respects Ansible's specific precedence rules (e.g., extra vars overriding role defaults).
github.com/aquasecurity/trivy · high confidence
Misconfiguration scanning for container image history
The system now analyzes the history of container images to detect misconfigurations. It reconstructs a virtual Dockerfile from the image's layer history (including support for BuildKit and legacy Docker builder formats) and runs security checks against it. This allows users to identify issues such as using ADD instead of COPY or missing health checks directly from the image metadata, even when the original Dockerfile is not available.
pkg/fanal/analyzer/imgconf/dockerfile · high confidence
Native discovery of OpenVEX documents from OCI artifacts
Users can now automatically discover and retrieve OpenVEX (Vulnerability Exploitability eXchange) documents attached to OCI images. The system fetches VEX attestations stored as OCI 1.1 referrers (supporting Sigstore bundles, DSSE envelopes, and in-toto predicates) and falls back to legacy Cosign v2 \.att\ tags if necessary. This enables automatic vulnerability context resolution for OCI packages without manual intervention, with safeguards against unbounded fetches and decompression attacks.
pkg/vex/oci · high confidence
Native support for VEX documents in CSAF, CycloneDX, OpenVEX, and Repository formats
Users can now filter detected vulnerabilities using Vulnerability Exploitability eXchange (VEX) documents. The system natively parses and applies filtering logic for CSAF, CycloneDX, and OpenVEX formats, allowing users to mark vulnerabilities as 'not affected' or 'fixed' based on vendor statements. Additionally, the tool supports discovering VEX attestations from OCI registries, loading external VEX files referenced in CycloneDX SBOMs, and querying local VEX repositories configured via a repository index, providing a unified way to suppress false positives across multiple VEX standards.
pkg/vex · high confidence
New ARM adapters for Azure Database and Monitor resources
Added new infrastructure-as-code adapters in the ARM (Azure Resource Manager) adapter layer to parse and model Azure Database (MySQL, PostgreSQL, MariaDB, SQL) and Monitor (Log Profiles) resources. The database adapter extracts server configurations such as SSL enforcement, TLS versions, public network access, firewall rules, and specific settings like extended auditing policies and threat detection, while the monitor adapter captures log profile retention policies and categories. These changes enable Trivy to analyze these specific Azure resource types for misconfigurations during IaC scans.
pkg/iac/adapters/arm/database · high confidence
New Alpine APK history analyzer for image configuration
A new config analyzer has been added for Alpine Linux images that parses the Docker image history to reconstruct the full list of installed APK packages, including their dependencies and versions. By fetching an external APKINDEX archive, the analyzer resolves virtual packages and shared object dependencies, providing a more complete view of the image's package state for vulnerability and misconfiguration scanning.
pkg/fanal/analyzer/imgconf/apk · high confidence
New Alpine APK package analyzer with dependency graph and metadata support
A new analyzer has been added for Alpine Linux APK packages, enabling the extraction of detailed package metadata including licenses, maintainers, and SHA1 digests. The analyzer also builds a dependency graph by resolving package names and virtual provides to specific package IDs, and reports the list of installed files for each package.
pkg/fanal/analyzer/pkg/apk · high confidence
New Azure ARM template scanner
Users can now scan Azure Resource Manager (ARM) templates for misconfigurations. This change introduces a new scanner in the \pkg/iac/scanners/azure/arm\ package that parses ARM deployment files and applies Rego-based checks to detect issues, integrating with the existing IaC scanning framework.
pkg/iac/scanners/azure/arm · high confidence
New Azure Terraform adapter for misconfiguration scanning
The \pkg/iac/adapters/terraform/azure\ package has been introduced to adapt Terraform Azure resources into an internal schema for security and compliance checks. This new adapter covers key service areas including App Service (supporting \azurerm\_linux\_web\_app\ and \azurerm\_windows\_web\_app\), Authorization (Role Definitions and Assignments), Compute (Virtual Machines and Managed Disks), Container (Kubernetes Clusters with RBAC and Azure Policy support), Cosmos DB, Database (PostgreSQL, MySQL, MariaDB), and more. It replaces previous adaptation logic, ensuring that configuration attributes like TLS versions, encryption settings, and network access rules are correctly parsed for downstream security checks.
pkg/iac/adapters/terraform/azure · high confidence
New Azure deployment and value models for ARM template scanning
The Azure scanner now includes new data models in pkg/iac/scanners/azure to represent Azure Resource Manager (ARM) deployment structures and configuration values. The deployment.go file introduces structs for Deployment, Parameter, Variable, Resource, and Output, enabling the scanner to parse and traverse ARM template resources by type. The value.go file defines a Value type with explicit Kind enumeration (e.g., string, number, object, expression) and implements JSON unmarshaling using the new encoding/json/v2 package, allowing for more robust handling of ARM template values including expressions and type coercion. These changes provide the foundational data structures for scanning Azure infrastructure-as-code configurations.
pkg/iac/scanners/azure · high confidence
New CloudFormation scanner with inline ignore support
A new CloudFormation scanner has been added, enabling misconfiguration checks on AWS CloudFormation templates. The scanner parses YAML/JSON templates, adapts them for Rego-based policy evaluation, and supports inline ignore directives (e.g., \#trivy:ignore:RULE\_ID) within the template files to suppress specific findings.
pkg/iac/scanners/cloudformation · high confidence
New Debian OS package vulnerability scanner
A new scanner implementation for Debian OS packages has been added to the detection pipeline. This component scans installed Debian packages against the Debian Security Tracker database, reporting vulnerabilities with their fixed versions, severity, and status (including 'WillNotFix'). It also includes logic to determine if a specific Debian release is still supported based on End-of-Life (EOL) dates, ensuring that unsupported versions are handled correctly during scanning.
pkg/detector/ospkg/debian · high confidence
New Go module parser with stdlib and main module support
A new parser for Go modules has been added to the dependency analysis engine. It now identifies the main module as the root package and, when enabled, reports the Go standard library (stdlib) version derived from the \toolchain\ directive (falling back to the \go\ directive). The parser also constructs explicit dependency relationships for the main module and respects the \replace\ directive to update package versions and paths. Additionally, it correctly handles indirect dependencies by skipping them for Go versions prior to 1.17, requiring go.sum merging for complete coverage in those cases.
pkg/dependency/parser/golang/mod · high confidence
New Google Cloud IAM Terraform adapter
Added a new adapter in \pkg/iac/adapters/terraform/google/iam\ that translates Terraform configurations for Google Cloud IAM resources into Trivy's internal data model. This enables security scanning for Identity and Access Management settings across Organizations, Folders, and Projects, including support for IAM members, bindings, policies, audit configs, and Workload Identity Pool Providers.
pkg/iac/adapters/terraform/google/iam · high confidence
New Google Compute resource adapter
Added a new adapter in \pkg/iac/adapters/terraform/google/compute\ that translates Terraform \google\compute\\*\ resources into internal security models. This adapter now supports adapting Compute Instances (including shielded VM configs, service accounts, and metadata flags), Disks (with KMS and raw encryption keys), Networks (linking subnetworks and firewall rules), and SSL Policies. It also introduces support for the \private\_ip\_google\_access\ attribute on subnetworks and correctly parses boolean metadata values in various formats.
pkg/iac/adapters/terraform/google/compute · high confidence
New IaC configuration analyzers for Ansible, Azure ARM, and Terraform Plan formats
The configuration analyzer package now includes dedicated post-analyzers for Ansible (ansible.cfg, .yml, .yaml, .json, .ini), Azure ARM templates (.json, excluding CreateUiDefinition), and Terraform Plan files (both JSON and snapshot formats). These new analyzers, alongside existing ones for Dockerfile, Helm, Kubernetes, CloudFormation, JSON, and YAML, are registered in the global import bundle to automatically detect and scan these infrastructure-as-code files for misconfigurations.
pkg/fanal/analyzer/config · high confidence
New IaC type-to-Rego conversion logic with metadata support
The \pkg/iac/rego/convert\ package now provides the core logic for converting internal Infrastructure-as-Code types into Rego-compatible maps. This includes handling structs and slices, automatically extracting metadata via the \GetMetadata\ method or \Metadata\ field into a \\_\_defsec\_metadata\ key, and implementing the \Converter\ interface to allow custom types to define their own \ToRego\ serialization. Tests confirm that complex nested structures and specific IaC types like \types.StringValue\ are correctly flattened into the expected map format for policy evaluation.
pkg/iac/rego/convert · high confidence
New JSON and table compliance report formats
Users can now generate compliance scan results in JSON and table formats. The JSON output supports two modes: 'all' for the complete report structure and 'summary' for a condensed view. The table output similarly offers a detailed view of individual control checks or a summarized table showing control IDs, severity, names, pass/fail status, and issue counts. This functionality is implemented in the \pkg/compliance/report\ package, which introduces the \JSONWriter\, \TableWriter\, and \SummaryWriter\ components to handle these new output styles.
pkg/compliance/report · high confidence
New Kubernetes manifest scanner supporting YAML and JSON
A new Kubernetes scanner has been added, enabling the scanning of Kubernetes manifests in both YAML and JSON formats. This change introduces a dedicated scanner component that leverages the generic scanner framework to parse manifest files and apply Rego-based security policies, allowing users to detect misconfigurations in their Kubernetes resources regardless of whether the input is YAML or JSON.
pkg/iac/scanners/kubernetes · high confidence
New Kubernetes scan report writers and consolidated reporting logic
The \pkg/k8s/report\ package now includes dedicated writers for generating Kubernetes scan results in JSON, CycloneDX, table, and summary formats. This change introduces a \Report\ structure that supports both detailed (\all\) and consolidated (\summary\) views, allowing users to see either full resource-level findings or aggregated counts by severity. The CycloneDX writer specifically supports the KBOM (Kubernetes Bill of Materials) format, enabling SBOM-style reporting for cluster resources. Additionally, the summary report logic consolidates vulnerabilities, misconfigurations, and secrets per resource, while the table writer handles context updates for multi-container pods and node components.
pkg/k8s/report · high confidence
New Kubernetes scanner implementation with Windows filename support
The \pkg/k8s/scanner\ package introduces a new scanner implementation that processes Kubernetes artifacts by generating temporary YAML files for misconfiguration and RBAC scanning, and handles image vulnerability scanning in parallel. A key behavioral change is the addition of Windows-compatible filename generation for temporary files, ensuring that special characters (like colons and slashes) in Kubernetes resource names are sanitized to prevent file system errors on Windows. The scanner also supports CycloneDX BOM output for cluster info and filters core component vulnerabilities.
pkg/k8s/scanner · high confidence
New Kubernetes scanning and reporting capabilities
This change introduces the \pkg/k8s\ package, enabling the scanning of Kubernetes core components and the generation of reports in JSON, table, and CycloneDX formats. Users can now scan k8s resources for vulnerabilities, misconfigurations, and secrets, with the ability to view suppressed vulnerabilities and separate infrastructure from user findings in summary reports.
pkg/k8s · high confidence
New Node.js package.json parser with validation and legacy support
A new parser for \package.json\ files has been added to the Node.js dependency analysis. It now validates package names against URL-friendly character rules, rejecting invalid formats. The parser also supports legacy license formats, including string, object, and array-of-objects structures, ensuring broader compatibility with older npm packages. Additionally, it handles the \workspaces\ field in both string array and object map formats, extracting workspace paths correctly for monorepo structures.
pkg/dependency/parser/nodejs/packagejson · high confidence
New PKCS\#12 and X.509 cryptographic asset parsers
The crypto parser now includes dedicated support for PKCS\#12 keystores and enhanced X.509 asset description. The new PKCS\#12 parser extracts unencrypted X.509 certificates from password-less keystores (such as those generated by OpenSSL or keytool), while explicitly skipping encrypted, enveloped, or public-key-signed content. The X.509 parser now describes cryptographic material as structured assets, including certificates, public/private keys, and encrypted private keys, and handles keys that standard libraries cannot fully decode by reporting them as raw assets. This change introduces the underlying parsing logic and test coverage for these formats.
pkg/crypto/parser/x509 · high confidence
New Rust Cargo lockfile parser with line-number tracking
A new parser implementation for Rust Cargo lockfiles has been added to the dependency analysis engine. This change introduces a dedicated parser that not only extracts package names and versions but also tracks the specific line numbers where each package is defined in the lockfile. It supports both legacy Cargo.lock formats and the newer v3 format, correctly handling complex dependency scenarios such as multiple versions of the same package and mixed dependency formats.
pkg/dependency/parser/rust/cargo · high confidence
New Terraform adapter for GitHub repository, branch protection, and environment secret resources
This change introduces the initial implementation of the GitHub adapter within the Terraform scanning pipeline. It adds support for adapting three specific resource types: \github\_repository\ (extracting visibility and vulnerability alert settings, with precedence given to the standalone \github\_repository\_vulnerability\_alerts\ resource), \github\_branch\_protection\ (extracting the signed commits requirement), and \github\_actions\_environment\_secret\ (extracting secret metadata and values). This allows the security scanner to evaluate these GitHub-specific configurations against defined policies.
pkg/iac/adapters/terraform/github · high confidence
New Terraform adapters for AWS Access Analyzer, API Gateway, Athena, CloudFront, CloudTrail, and CloudWatch
This change introduces new infrastructure-as-code adapters for several AWS services, enabling Trivy to analyze Terraform configurations for Access Analyzer, API Gateway (both v1 and v2), Athena, CloudFront, CloudTrail, and CloudWatch. The adapters parse specific Terraform resource blocks (such as \aws\_accessanalyzer\_analyzer\, \aws\_api\_gateway\_rest\_api\, \aws\_athena\_workgroup\, \aws\_cloudfront\_distribution\, \aws\_cloudtrail\, and \aws\_cloudwatch\_log\_group\) and map their attributes—like encryption settings, logging configurations, and security policies—into a unified internal model. This allows security checks to evaluate these resources for misconfigurations, such as unencrypted data or missing logging, directly from the user's Terraform code.
pkg/iac/adapters/terraform/aws · high confidence
New Terraform and CloudFormation IAC adapters for multiple cloud providers
This change introduces new infrastructure-as-code adapters that allow Trivy to analyze Terraform and CloudFormation templates for AWS, Azure, Google Cloud, Kubernetes, Oracle, and other providers. Specifically, it adds the \pkg/iac/adapters/cloudformation\ package to adapt CloudFormation stacks and expands the \pkg/iac/adapters/terraform\ package with new sub-packages for Google, Kubernetes, and Oracle, enabling the detection of security issues in these specific infrastructure definitions.
(repo-wide) · high confidence
New Yarn language analyzer with license, workspace, and dependency detail support
A new post-analyzer for Yarn has been added to the Node.js language detection pipeline. This analyzer processes yarn.lock files to identify packages, their versions, and dependency relationships (root, direct, indirect, workspace). It also parses the accompanying package.json to distinguish between production and development dependencies, extracts license information from node\_modules, and supports Yarn Berry (v3) configurations via .yarnrc.yml. Test data includes examples for classic Yarn with license files and Yarn Berry with node-modules linker.
pkg/fanal/analyzer/language/nodejs/yarn · high confidence
New analyzers for SBT lockfiles and Python pylock.toml
Trivy now detects dependencies in SBT projects using the \build.sbt.lock\ file and in Python projects using the PEP 751 \pylock.toml\ format. The SBT analyzer registers as a standard analyzer, while the pylock analyzer is implemented as a post-analyzer that also parses \pyproject.toml\ to distinguish between direct and indirect dependencies.
pkg/fanal/analyzer · high confidence
New clean subcommand to selectively remove cached data
Users can now use the \clean\ subcommand to selectively remove specific types of cached data, including the scan cache, vulnerability database, Java database, check bundles, and VEX repositories. The command supports a \--all\ flag to remove all cached data at once, or individual flags to target specific components, providing more granular control over cache management.
pkg/commands/clean · high confidence
New convert command to transform Trivy JSON reports
A new 'convert' command has been added to allow users to read a Trivy JSON report and re-output it in a different format (such as table, JSON, or SARIF). The command handles backward compatibility by automatically filling in missing package UIDs in older report files and supports filtering results. It explicitly notes that AWS and Kubernetes scanning reports are not yet supported for conversion.
pkg/commands/convert · high confidence
New digest package for computing file hashes
A new \pkg/digest\ package has been introduced to provide utilities for calculating and managing cryptographic digests. It supports SHA-1, SHA-256, SHA-512, and MD5 algorithms, allowing users to generate standardized digest strings (e.g., \sha256:...\) from byte slices or readers. This adds the capability to compute file checksums using these specific hashing methods.
pkg/digest · high confidence
New filesystem utility functions for directory and file checks
A new \fsutils\ package has been added to \pkg/utils\, providing helper functions to determine if a path is a directory (\DirExists\) or a regular file (\FileExists\), as well as utilities to locate the Trivy home directory and copy files. It also introduces a \WalkDir\ function that allows filtering files by extension during directory traversal, with debug logging for any errors encountered during the walk.
pkg/utils · high confidence
New generic and case-insensitive set implementations
The \pkg/set\ package now provides a generic \Set\[T\]\ interface and two concrete implementations: a standard case-sensitive set (\unsafe.go\) and a case-insensitive string set (\case\_insensitive.go\). The generic set supports any comparable type and includes operations like Append, Remove, Contains, Union, Intersection, and Difference. The case-insensitive string set specifically handles string comparisons without regard to case, preserving the casing of the first occurrence of each unique string. Both implementations are non-thread-safe and include comprehensive test coverage.
pkg/set · high confidence
New license file analyzer for source code and license headers
A new license file analyzer has been added to the fanal package, enabling the detection of software licenses within source code files (such as C, Java, Python, and JavaScript) and standard license files (like LICENSE or COPYING). The analyzer scans text-based files, skipping binary content and specific system directories (e.g., node\_modules, usr/share/doc), and classifies licenses using a configurable confidence level. This change introduces the capability to identify license types directly from file headers and dedicated license files, integrating with the existing analysis pipeline via the \analyzer.TypeLicenseFile\ type.
pkg/fanal/analyzer/licensing · high confidence
New npm post-analyzer for license detection and lock file parsing
A new post-analyzer has been added for the npm language type to improve dependency analysis. It parses package-lock.json files to extract package details, including dependency line numbers and external references. Additionally, it traverses the node\_modules directory to collect license information from package.json files, filling in license data for packages where it is missing from the lock file. The analyzer specifically excludes package-lock.json files located inside node\_modules to prevent duplication and false positives.
pkg/fanal/analyzer/language/nodejs/npm · high confidence
New pip analyzer with license detection and minimum version support
The pip analyzer has been rewritten to support license detection by reading package metadata from the site-packages directory and to use minimum version constraints when the detection priority is set to comprehensive. This change introduces a new post-analyzer implementation that walks requirements files, resolves package licenses, and integrates with the updated Python dependency parser.
pkg/fanal/analyzer/language/python/pip · high confidence
New pip requirements.txt parser with line-level location tracking
A new parser for Python \requirements.txt\ files has been added to the pip dependency analysis module. This parser extracts package names and versions, supporting multiple version specifiers (e.g., \\>=\, \==\, \\~=\) and extras (e.g., \\[crypto\]\). It also handles encoding issues like UTF-16 BOMs and validates package names and versions against PEP 508 standards. Crucially, it now records the specific line number where each dependency is defined, enabling more precise vulnerability reporting and source attribution for Python projects.
pkg/dependency/parser/python/pip · high confidence
New policy client for OCI-based misconfiguration checks
A new policy client has been introduced in pkg/policy to manage the download and caching of misconfiguration check bundles from OCI registries. The client defaults to fetching the bundle from mirror.gcr.io/aquasec/trivy-checks:2 and tracks the bundle's major version and digest to determine when updates are needed. This change establishes the core mechanism for retrieving and validating policy bundles, supporting features like custom repositories and OCI artifact integration.
pkg/policy · high confidence
New post-analyzer for Java JAR/WAR/EAR/PAR files
A new post-analyzer has been added to detect Java libraries within JAR, WAR, EAR, and PAR archives. It integrates with the trivy-java-db to resolve package names, versions, and licenses, and correctly handles nested JARs by preserving per-file digests rather than overwriting them with the enclosing archive's digest.
pkg/fanal/analyzer/language/java/jar · high confidence
New rule registry and provider hierarchy APIs
The \pkg/iac/rules\ package now includes a new \register.go\ file that implements a thread-safe registry for infrastructure-as-code rules, supporting registration, deregistration, and retrieval of rules by framework or compliance specification. Additionally, a new \providers.go\ file introduces functions to expose the hierarchy of providers, services, and checks (e.g., \GetProviders\, \GetProvidersHierarchy\), enabling users to query the available security checks organized by provider and service. These changes provide a structured way to discover and manage rules programmatically.
pkg/iac/rules · high confidence
New table-format renderers for licenses, misconfigurations, secrets, and summary
The table report output now includes dedicated renderers for license findings (both package-level and file-level), misconfigurations, and secrets, in addition to the existing vulnerability renderer. License tables display package name, license identifier, classification, and severity, with file-level licenses also showing the file path. Misconfiguration output now renders individual findings with their ID, severity, status (pass/fail/exception), description, and source code context, including line numbers and cause metadata. Secret findings are displayed with severity, category, rule ID, title, and source code context, including byte offset and Docker layer information. A new summary table provides a high-level overview of findings across all enabled scanners (vulnerabilities, misconfigurations, secrets, licenses) per target.
pkg/report/table · high confidence
New utility for opening and decompressing gzip files with proper resource cleanup
A new \OpenFile\ function has been added to the \pkg/fanal/utils/gzip\ package, allowing users to open files that may be gzipped. This utility automatically detects gzip content and wraps the reader in a \multiCloser\ to ensure that both the underlying file handle and the gzip reader are properly closed, preventing resource leaks.
pkg/fanal/utils/gzip · high confidence
New utility functions for file analysis and path handling
Added a new utils package in pkg/fanal/utils containing helper functions for file system operations. This includes IsGzip for detecting gzip files, IsExecutable for checking file executability (including Windows .exe and unpackaged binaries), IsBinary for identifying binary content, ExtractPrintableBytes for scanning file content, and CleanSkipPaths/SkipPath for managing file exclusion patterns using doublestar matching. The package also provides CacheDir and IsCommandAvailable helpers.
pkg/fanal/utils · high confidence
New version check and announcement system with targeted notifications
The notification package now implements a new background version-checking mechanism that contacts the Trivy updates API to retrieve the latest version and any server-side announcements. Users will see a notice when a new version is available, and can suppress these checks using the --skip-version-check flag. Announcements from the server can now include version constraints (from\_version, to\_version) and date ranges, allowing the system to display targeted messages only to relevant users. The system also sends anonymous telemetry headers (including a unique machine identifier) when telemetry is not disabled, while suppressing debug logs for context cancellation errors.
pkg/notification · high confidence
Node.js license analysis now resolves file-based license references
The Node.js license analyzer now supports packages that specify their license via a reference to an external file (e.g., 'LicenseRef-LICENSE.txt' or 'SEE LICENSE IN LICENSE.md') rather than an inline SPDX identifier. When a package.json lacks a direct license string, the analyzer automatically locates the referenced license file within the package directory and classifies its contents to determine the actual license, ensuring more accurate license detection for projects using this convention.
pkg/fanal/analyzer/language/nodejs/license · high confidence
NuGet analyzer now extracts license information and dependency locations from lock files
The NuGet analyzer in the dotnet language package has been updated to parse \packages.lock.json\ files for richer dependency metadata. Users will now see license information populated for packages by reading the corresponding \.nuspec\ files from the global NuGet packages directory (respecting the \NUGET\_PACKAGES\ environment variable or defaulting to \\~/.nuget/packages\). Additionally, the analyzer now records the specific file locations (line ranges) where each dependency is defined in the lock file and identifies direct dependencies via the \DependsOn\ field, providing more granular visibility into the dependency graph.
pkg/fanal/analyzer/language/dotnet/nuget · high confidence
OCI artifact download and referrer discovery
Users can now download single-layer OCI artifacts (such as vulnerability databases, policies, SBOMs, and VEX documents) via the new Artifact component, which handles registry authentication, media-type validation, and path-traversal protection. Additionally, the Referrers function enables discovery of OCI 1.1 referrers filtered by specific artifact types, supporting native detection of VEX documents, SBOMs, and Sigstore bundles stored as OCI artifacts.
pkg/oci · high confidence
Python package analysis now supports .egg archives and .egg-info/METADATA files
The Python packaging analyzer has been split into two components to broaden coverage: a new \eggAnalyzer\ now processes \.egg\ archives (which are ZIP files) by extracting \PKG-INFO\ and license files, while the existing \packagingAnalyzer\ has been updated to recognize \.egg-info\ directories and their \METADATA\ files in addition to the standard \.dist-info\ and wheel formats. This change ensures that older Python distribution formats are analyzed for package names, versions, and license information alongside modern distributions.
pkg/fanal/analyzer/language/python/packaging · high confidence
Registration of new analyzers in the global analyzer registry
The \pkg/fanal/analyzer/all\ package now registers a comprehensive set of new analyzers via side-effect imports, enabling support for additional operating systems (Bottlerocket, Azure Linux), package managers (uv, pylock, pnpm, bun, conan, sbt-dependency-lock, mix.lock, pubspec.lock, Package.resolved), and scanning capabilities (non-packaged binaries, crypto scanning, license scanning, SBOM analysis, and secret scanning in image configs).
pkg/fanal/analyzer/all · high confidence
SBOM retrieval from Rekor transparency log
Users can now retrieve Software Bill of Materials (SBOM) attestations stored in the Rekor transparency log. This new capability allows the tool to fetch CycloneDX-formatted SBOMs by searching Rekor records using a digest, enabling verification and retrieval of SBOM data that has been attested and recorded in the log.
pkg/attestation/sbom · high confidence
Scan reports now include unique vulnerability fingerprints and stable artifact IDs
Scan reports now contain a deterministic SHA256 fingerprint for each vulnerability, enabling external systems to track and deduplicate findings across multiple scans. This is supported by a new \ArtifactID\ field that uniquely identifies the scanned target by combining the image ID with the registry and repository (for container images) or the repository URL and commit hash (for Git repositories). Additionally, the \ReportID\ has been updated to use UUIDv7, and the JSON output now includes the Trivy version and server information.
pkg/scan · high confidence
Support for SSL mode configuration in Google Cloud SQL instances
The adapter for Google Cloud SQL database instances now extracts the \ssl\_mode\ attribute from the Terraform \ip\_configuration\ block, allowing security checks to evaluate SSL enforcement settings. This change adds the \ssl\_mode\ field to the internal SQL instance model and includes corresponding test coverage to verify correct parsing of this configuration.
pkg/iac/adapters/terraform/google/sql · high confidence
Support for Ubuntu Extended Security Maintenance (ESM) detection
The Ubuntu OS analyzer now detects when Ubuntu Extended Security Maintenance (ESM) is enabled. It registers a new analyzer that reads the Ubuntu Advantage status file (\var/lib/ubuntu-advantage/status.json\) to check if the \esm-infra\ service is active; if so, the detected OS is marked as extended. This allows the scanner to correctly identify Ubuntu systems with ESM subscriptions, ensuring accurate vulnerability coverage for those environments.
pkg/fanal/analyzer/os/ubuntu · high confidence
Support for analyzing RPM archives and RPM database manifests
The RPM analyzer now detects packages from standalone .rpm archive files (in addition to system RPM databases and rpm-qa manifests). It parses the archive header to extract package metadata, including NEVRA fields, licenses, source RPM details, and vendor information, and generates a Package URL (PURL) with the appropriate namespace (e.g., redhat, fedora) and architecture qualifier. This enables scanning of individual RPM files directly, complementing the existing system-level RPM analysis.
pkg/fanal/analyzer/pkg/rpm · high confidence
Support for custom JSON Schema validation in misconfiguration scanning
Users can now provide custom JSON Schema files to validate configuration structures during misconfiguration scans. The \pkg/misconf\ package introduces a new \config\_schema.go\ module that loads \.json\ schema files from specified paths, resolving them using the \google/jsonschema-go\ library. The implementation includes compatibility adjustments for Go's regular expression engine, specifically replacing unsupported \\\Z\ anchors with \$\ and stripping negative lookaheads \(?!)\. This capability is exposed via the \ConfigFileSchemas\ option in the scanner configuration, allowing users to enforce stricter structural validation on their IaC files beyond standard policy checks.
pkg/misconf · high confidence
Support for detecting and scanning SBOM attestations and Sigstore bundles
The SBOM detection logic in \pkg/sbom\ has been expanded to recognize and process Software Bill of Materials (SBOM) data embedded within in-toto attestations and Sigstore bundles. Users can now scan SBOMs packaged as CycloneDX or SPDX attestations (including legacy Cosign formats) and Sigstore bundles (v0.3) containing CycloneDX or SPDX payloads, in addition to standard SBOM files.
pkg/sbom · high confidence
Support for detecting vulnerabilities in unpackaged binaries via Rekor SBOM attestations
A new post-handler has been added to retrieve Software Bill of Materials (SBOM) attestations from the Rekor transparency log for executable files that are not managed by OS package managers. By matching file digests against Rekor, the system can now detect applications and their dependencies within unpackaged binaries, enabling vulnerability scanning for these previously unanalyzable files.
pkg/fanal/handler/unpackaged · high confidence
Support for parsing Sigstore DSSE envelope attestations
The attestation package now includes logic to parse Sigstore bundles containing DSSE envelopes, enabling the system to correctly unwrap and decode in-toto statements from Cosign v3+ bundle formats. This change allows users to process SBOM and other attestation data embedded in these standardized security bundles without manual envelope extraction.
pkg/attestation · high confidence
Support for pnpm v9 lockfiles and multi-document parsing
The pnpm dependency parser now supports lockfile format v9, which uses a 'snapshots' structure to represent packages with their exact resolved dependencies. It also handles pnpm v11+ multi-document lockfiles by skipping the environment configuration document and parsing only the project lockfile, and correctly identifies direct versus transitive dependencies across multiple workspaces in pnpm v9.
pkg/dependency/parser/nodejs/pnpm · high confidence
Support for remote SBOM discovery via OCI referrers and Rekor attestations
The container image analyzer now attempts to retrieve pre-generated SBOM documents before performing a local scan. It checks configured SBOM sources—specifically OCI artifact referrers and Sigstore Rekor attestations—and uses the first valid SBOM found, allowing users to skip expensive local analysis when a trusted remote SBOM is available.
pkg/fanal/artifact/image · high confidence
Support for scanning AWS AMI, EBS snapshots, and local VM images
Users can now scan virtual machine artifacts directly using the \vm\ artifact type. This change introduces support for three specific sources: Amazon Machine Images (AMI), Amazon EBS snapshots, and local VM image files (such as raw images or VMDKs). The implementation in \pkg/fanal/artifact/vm\ handles the necessary AWS SDK interactions for AMI/EBS and file system walking for local images, integrating them into the existing analysis pipeline with caching and post-analysis support.
pkg/fanal/artifact/vm · high confidence
Support for scanning Terraform Plan JSON files
Users can now scan Terraform plan JSON files (\.tfplan.json\) for misconfigurations. A new scanner in the \tfjson\ package parses these plan files, converts them into a filesystem representation, and delegates the actual security checks to the existing Terraform scanner, allowing users to detect issues in planned infrastructure changes before they are applied.
pkg/iac/scanners/terraformplan/tfjson · high confidence
Support for scanning Terraform Plan snapshots
Users can now scan Terraform Plan snapshots (zip archives containing the plan file and configuration) in addition to standard Terraform directories. The new snapshot scanner extracts the plan's input variables and reconstructs the configuration files into a virtual filesystem, allowing the existing Terraform scanner to evaluate the planned state against security policies.
pkg/iac/scanners/terraformplan/snapshot · high confidence
Support for scanning container images via Docker, Podman, and containerd daemons
The \pkg/fanal/image/daemon\ package now provides a unified interface for scanning images directly from local container runtimes. It introduces dedicated implementations for Docker, Podman, and containerd, allowing users to scan images by name, tag, or digest. The Docker implementation adds intelligent host resolution, prioritizing the \--docker-host\ flag, then \DOCKER\_HOST\, then \DOCKER\_CONTEXT\, and finally the current context. The containerd implementation supports scanning by digest and allows overriding the namespace via the \CONTAINERD\_NAMESPACE\ environment variable. The Podman implementation enables custom socket paths. All implementations share a common image wrapper that optimizes config retrieval by leveraging daemon API responses while falling back to full image export only when necessary.
pkg/fanal/image/daemon · high confidence
Support for scanning local and remote Git repositories
Users can now scan local directories and remote Git repositories as artifacts. The system automatically detects whether a target is a local path or a remote URL; for remote repositories, it clones the repository (supporting specific branches, tags, or commit hashes) into a temporary directory for scanning. Authentication is supported via GITHUB\_TOKEN or GITLAB\_TOKEN environment variables, and credentials are redacted from logs and report metadata to prevent leakage.
pkg/fanal/artifact/repo · high confidence
Support scanning SBOM files as artifacts
Users can now scan Software Bill of Materials (SBOM) files directly as artifacts. The new \pkg/fanal/artifact/sbom\ package implements an artifact handler that auto-detects SBOM formats (including CycloneDX and SPDX, both JSON and XML, as well as attestation formats) and decodes them into the internal representation. This allows vulnerability scanning and analysis to be performed on existing SBOM reports, preserving the original structure and package identifiers found within the SBOM.
pkg/fanal/artifact/sbom · high confidence
Terraform Plan scanner now supports variable extraction
The Terraform Plan scanner can now extract and expose Terraform variables from plan files. This is enabled by a new Protocol Buffers schema (planfile.proto) that defines a Plan message containing a map of variable names to their dynamic values, allowing downstream components to access variable data during scanning.
pkg/iac/scanners/terraformplan/snapshot/planproto · high confidence
Terraform executor now renders specific code causes for failed checks
The Terraform scanner executor now includes rendered code snippets (causes) for failed security checks. When a check fails, the executor identifies the specific Terraform block and attributes responsible for the violation and formats them into a readable HCL snippet. This provides users with immediate, contextual visibility into exactly which lines of their infrastructure code triggered the failure, rather than just a generic rule ID.
pkg/iac/scanners/terraform/executor · high confidence
Terraform plan JSON parsing and HCL rendering support
Added a new parser component in \pkg/iac/scanners/terraformplan/tfjson/parser\ that reads Terraform plan JSON files and converts them into a virtual HCL file system. This enables downstream scanners to analyze Terraform plans using standard HCL-based logic, including support for nested blocks, complex attributes, and resource references.
pkg/iac/scanners/terraformplan/tfjson/parser · high confidence
Ubuntu vulnerability scanner now supports ESM versions and extended data sources
The Ubuntu OS package detector now handles Ubuntu Extended Security Maintenance (ESM) versions (e.g., 18.04-ESM, 20.04-ESM) by mapping them to their base release for vulnerability lookups when the base release is still supported, and falling back to ESM-specific data when the base release is end-of-life. The scanner also includes a comprehensive list of End-of-Life (EOL) dates for Ubuntu releases up to 26.04, ensuring accurate version support checks. Additionally, detected vulnerabilities now include detailed data source information (ID, name, and URL) from the Ubuntu CVE Tracker, improving transparency for users.
pkg/detector/ospkg/ubuntu · high confidence
Unified Kubernetes scanning with CycloneDX SBOM and compliance report support
The \trivy k8s\ command now supports generating CycloneDX Software Bill of Materials (SBOM) for the entire cluster via the \--format cyclonedx\ flag, in addition to existing JSON and table formats. The scan logic has been unified to handle cluster artifacts and node information (via the node-collector) consistently across formats, allowing users to exclude/include specific namespaces and resource kinds. Furthermore, when a compliance specification is provided, the tool now builds and writes structured compliance reports, enabling users to validate their Kubernetes clusters against specific compliance controls.
pkg/k8s/commands · high confidence
Architecture
Introduce intermediate BOM representation for SBOM generation
The SBOM generation logic now utilizes a new intermediate representation (BOM) defined in the core package. This internal data structure standardizes how components, relationships, and vulnerabilities are modeled before being serialized into specific formats like CycloneDX or SPDX, laying the groundwork for improved consistency and features such as external VEX file support.
pkg/sbom/core · high confidence
Behavioural changes
2 commits (0 fixes) modifying pkg/crypto/parser/jks
A change to existing behaviour in pkg/crypto/parser/jks — 2 commits, 5 files: “feat(crypto): read certificates from JKS keystores (\#11400)”; “feat(crypto): report private keys from PKCS\#12 and JKS keystores (\#11524)” (refs \#11400, \#11524).
pkg/crypto/parser/jks · medium confidence · unverified
8 commits (0 fixes) modifying pkg/fanal/analyzer/crypto
A change to existing behaviour in pkg/fanal/analyzer/crypto — 8 commits, 4 files: “feat(crypto): read unencrypted certificates from PKCS\#12 keystores (\#11399)”; “feat(crypto): describe keys that crypto/x509 cannot parse (\#11404)”; “feat(crypto): read certificates from JKS keystores (\#11400)”; and 5 more (refs \#11399, \#11404, \#11400, \#10970, \#11431, …).
pkg/fanal/analyzer/crypto · medium confidence · unverified
AWS and Azure provider schemas restructured for IaC scanning
The internal data models for AWS and Azure infrastructure-as-code providers have been reorganized into a new, modular schema structure. This change introduces dedicated packages for each service (e.g., \aws/ec2\, \aws/s3\, \azure/appservice\) with clearly defined types for resources, encryption, logging, and access controls. For users, this ensures more accurate and granular security checks against cloud configurations, as the scanner now has a richer, standardized representation of cloud resources to evaluate against compliance rules.
pkg/iac/providers · high confidence
AWS configuration loading logic moved to dedicated package
The logic for loading AWS configuration, including region and custom endpoint resolution, has been moved from the general config package into a new dedicated \pkg/config/aws\ package. This change reorganizes the codebase structure without altering the external behavior of AWS configuration loading, making the AWS-specific setup logic more modular and easier to maintain.
pkg/config · high confidence
Add utility functions for deduplicating packages and merging maps
The dependency parser now includes a new \UniquePackages\ utility that deduplicates packages by name and version, merging their file locations and ensuring that if a package appears as both a root and a dev dependency, it is correctly marked as a root dependency. Additionally, a \MergeMaps\ helper is provided to safely clone and merge string maps, preventing shadow overwrites during dependency analysis.
pkg/dependency/parser/utils · high confidence
CLI restructured with command grouping and graceful shutdown
The Trivy CLI has been reorganized to improve usability and reliability. Commands are now categorized into Scanning, Management, Utility, and Plugin groups for clearer help output. The application now supports graceful shutdown via signal handling (SIGINT/SIGTERM), allowing operations to complete and temporary files to be cleaned up before exit. Additionally, the CLI now includes dedicated commands for VEX repositories, registry authentication, and configuration scanning, alongside support for loading external plugins.
pkg/commands · high confidence
Dockerfile parser now handles unknown flags and heredocs
The Dockerfile scanner's parser has been updated to gracefully handle Dockerfile instructions that contain unsupported or experimental flags by filtering them out instead of failing, and to correctly parse heredoc syntax in instructions like RUN. This allows the scanner to analyze Dockerfiles using newer or custom Docker features without throwing parse errors, ensuring broader compatibility with modern Dockerfile syntax.
pkg/iac/scanners/dockerfile/parser · high confidence
Dockerfile scanning now uses the generic scanner with inline ignore support
The Dockerfile scanner has been refactored to use the new generic scanner infrastructure, replacing the previous implementation. This change enables support for inline ignore comments in Dockerfiles, allowing users to suppress specific check results directly within their Dockerfile using standard ignore syntax.
pkg/iac/scanners/dockerfile · high confidence
Dpkg license detection and third-party package handling
The dpkg analyzer now detects package licenses by parsing copyright files in /usr/share/doc/\*/copyright, supporting both machine-readable License: fields and common license references, with a fallback to a classifier when the --license-full flag is enabled. Additionally, the analyzer identifies third-party packages by maintainer patterns (e.g., Docker, NVIDIA, HashiCorp) and excludes them from InstalledFiles tracking to prevent language scanners from incorrectly filtering out their dependencies.
pkg/fanal/analyzer/pkg/dpkg · high confidence
ECR authentication now supports custom TLS settings and dualstack endpoints
The ECR registry client has been rewritten to use the AWS SDK for Go v2, enabling support for dualstack ECR endpoints and allowing users to configure custom TLS options (such as \--cacert\ and insecure skip verify) via \RegistryOptions\. This change also improves region detection for various AWS partition endpoints (including FIPS and government clouds) and fixes authentication issues by using a buildable HTTP client instead of the previous generic client.
pkg/fanal/image/registry/ecr · high confidence
Enforce custom linting rules for error handling, maps, and temp files
A new linting rule set has been introduced to enforce specific coding standards across the codebase. Developers are now required to use the hashicorp/go-multierror library instead of the standard errors.Join for combining errors, initialize maps using make() rather than literal syntax, and replace map-based sets with the project's generic Set implementation. Additionally, temporary file and directory creation must use the process-safe wrappers from the x/os package instead of the standard os package to ensure safe cleanup.
misc/lint · high confidence
Expanded artifact scanning configuration and metadata support
The artifact scanning engine now supports a broader range of configuration options and richer metadata collection. Users can configure specific analyzers, file patterns, parallelism, and detection priorities via the new Option struct. The system now captures detailed Git repository metadata (branch, commit, tags) in scan results, supports Maven mirror configurations for Java scans, and allows for custom image platform and registry options. Additionally, SBOM attestation scanning via Rekor and file checksumming for SPDX output are now available.
pkg/fanal/artifact · high confidence
Filter system-installed packages from application analysis results
A new post-processing step removes application packages that were installed by the OS package manager (e.g., yum, dpkg) from the analysis results. This prevents false positive vulnerability detections that occur when language-specific package managers detect the same libraries installed via the system package manager, ensuring that only non-system-managed packages are reported for application-level scanning.
pkg/fanal/handler/sysfile · high confidence
Flag system refactored into modular groups with extension hooks
The flag system has been restructured into distinct, composable groups (e.g., AWS, Cache, Clean, DB, Global, Image, Kubernetes, License, Misconfiguration) that encapsulate their own flags and options, replacing the previous flat structure. This change introduces a new extension hook system in \pkg/extension\ that allows pre/post hooks for run, scan, and report phases, enabling extensibility. The refactoring also includes updates to specific flag behaviors, such as the deprecation of \--clear-cache\ in favor of \trivy clean --scan-cache\, the addition of \--disable-node-collector\ for Kubernetes scanning, and the introduction of \--license-confidence-level\ for license classification.
pkg/flag · high confidence
Go module analysis now runs as a post-analyzer with dependency graph and license support
The Go module analyzer has been rewritten as a post-analyzer, enabling it to construct a dependency graph that distinguishes between direct and indirect dependencies and correctly handles the \go\ directive when merging \go.sum\ data. It also scans for license information in both the \vendor\ directory and the \$GOPATH/pkg/mod\ cache, applying a configurable classifier confidence level to license detection.
pkg/fanal/analyzer/language/golang/mod · high confidence
Improved Go binary version detection with ELF symbol fallback and stdlib parsing fixes
The Go binary dependency parser now handles version detection more robustly by introducing a fallback mechanism for binaries built with the \-trimpath\ flag. When the standard build-info ldflags are missing due to this flag, the parser now reads version strings directly from the ELF symbol table (\.str\ symbols). Additionally, the parser correctly extracts the Go standard library version from the \GoVersion\ field, handling trailing metadata such as GOEXPERIMENT lists (including the new dash-separated format in Go 1.26+) and vendor build identifiers (e.g., Red Hat toolchains). The main module version resolution now follows a strict priority: build-info semver, then ldflags, then ELF symbol table, ensuring accurate version reporting even when primary sources are obscured or incomplete.
pkg/dependency/parser/golang/binary · high confidence
Improved Rust dependency analysis with direct/indirect classification and workspace support
The Cargo analyzer now distinguishes between direct and indirect dependencies by parsing Cargo.toml alongside Cargo.lock, correctly identifying root and workspace packages, and supporting workspace member globs and version inheritance. This results in more accurate dependency graphs for Rust projects, helping users better understand their dependency tree and potential security risks.
pkg/fanal/analyzer/language/rust/cargo · high confidence
Introduce DB client with schema validation and skip-update restrictions
The \pkg/db\ package now provides a dedicated client for managing the vulnerability database, introducing strict validation of the DB schema version against the CLI version. A key behavioral change is that the \--skip-db-update\ flag is now prohibited during the first run (when the DB file or metadata is missing) and when the local DB schema is outdated, preventing users from bypassing necessary updates or using incompatible database versions. The client also implements logic to detect potentially corrupted databases (indicated by a zero \DownloadedAt\ timestamp) and warns users to re-download the DB, while allowing skips only for recently downloaded files or when explicitly permitted by the user on valid, up-to-date databases.
pkg/db · high confidence
Introduce local scan service with OS distro override and PURL correlation
The local scanning logic is now implemented in a new \Service\ struct within \pkg/scan/local\, replacing the previous scattered implementation. This change introduces the ability to override the detected OS with a user-provided distro via \options.Distro\; when this override occurs, the service automatically regenerates PackageURLs (PURLs) for all OS packages to maintain correct correlation with the new OS metadata. The service also integrates pre- and post-scan extension hooks, manages vulnerability, license, and misconfiguration scanning in a unified flow, and includes comprehensive test coverage for both successful and error scenarios.
pkg/scan/local · high confidence
Introduce package UIDs and PURL identifiers for deterministic vulnerability mapping
The layer-appling logic in \pkg/fanal/applier\ now assigns a unique UID and a Package URL (PURL) to every detected OS and application package. This change ensures that packages are identified consistently across image layers, which eliminates non-deterministic scan results and duplicate entries when merging layers or handling embedded SBOMs. For users, this means more accurate vulnerability and license scanning, as each package instance is now uniquely traceable to its origin layer.
pkg/fanal/applier · high confidence
Introduce unified finding types and structured scan reports
The \pkg/types\ package has been restructured to define a unified type system for security findings. A new \Finding\ interface and \ModifiedFinding\ struct now standardize how vulnerabilities, misconfigurations, secrets, and licenses are represented, including support for VEX statuses (e.g., \not\_affected\, \fixed\) and ignore states. The \Report\ struct has been updated with an \ArtifactID\ for unique target identification, \ReportID\, and \CreatedAt\ timestamps, while \Result\ now explicitly categorizes findings via \ResultClass\ and includes a \ModifiedFindings\ list for experimental status overrides. Additionally, \DetectedVulnerability\ now includes a \Fingerprint\ for unique identification and \SeveritySource\ to track the origin of severity ratings.
pkg/types · high confidence
Introduces a modular, cached resolver system for Terraform modules
The \pkg/iac/scanners/terraform/parser/resolvers\ package has been restructured into a chain of specialized resolvers (Local, Remote, Registry, and Cache) to handle Terraform module sources. This change introduces a file-system cache layer that stores downloaded modules in a \.aqua\ directory, allowing subsequent scans to resolve modules from the local cache instead of re-downloading them. The Remote resolver now uses a cloned getter map to prevent data races during concurrent downloads, and the Registry resolver supports private registries via environment variables and OpenTofu-compatible download protocols.
pkg/iac/scanners/terraform/parser/resolvers · high confidence
JSON parsing now supports source code location tracking and JSONC syntax
The JSON parsing library has been rewritten to use the Go standard library's \encoding/json/v2\ and \encoding/json/jsontext\ packages, replacing the previous third-party \jfather\ implementation. This change introduces two key capabilities for users: first, the parser now tracks source code locations (start and end line numbers) for decoded JSON objects, allowing tools to pinpoint exactly where values appear in the original file; second, it adds support for JSONC (JSON with Comments), automatically stripping single-line (\//\) and multi-line (\/\* \*/\) comments as well as trailing commas while preserving character offsets so that location data remains accurate.
pkg/x/json · high confidence
Java DB client refactored to use normalized trivy-java-db
The Java database client has been rewritten to use the normalized \trivy-java-db\ structure, introducing a new \Updater\ that manages downloads from configurable OCI repositories (defaulting to GHCR and GCR mirrors) and enforces a single download per run. This change updates the database schema version handling, improves error reporting for metadata and download failures, and adds a \Clear\ function to allow users to manually purge the Java DB cache via the \trivy clean --java-db\ command.
pkg/javadb · high confidence
Java POM parser rewritten to support Maven settings, mirrors, and remote resolution
The Java POM dependency parser has been completely rewritten to provide robust Maven compatibility. It now reads and merges Maven \settings.xml\ (user and global), supporting proxy configuration, server credentials, and active profiles. The parser implements Maven's mirror resolution logic, allowing both \settings.xml\ mirrors and user-defined mirrors in the Trivy config file to redirect repository requests. It also supports resolving dependencies from remote repositories, including fetching \maven-metadata.xml\ for snapshot versions, and correctly inherits properties, versions, scopes, and repository definitions from parent POMs.
pkg/dependency/parser/java/pom · high confidence
License changed from MIT to Apache 2.0
The project license has been updated from the MIT License to the Apache License 2.0. This change affects the legal terms under which the software is distributed and used.
(repo-wide) · high confidence
License expression parsing and normalization refactored
The license expression handling in the licensing engine has been refactored to use a goyacc-based parser and lexer, replacing the previous implementation. This change introduces stricter normalization rules for SPDX license expressions, including canonical casing, replacement of invalid characters with hyphens, and correct handling of license exceptions. The update also embeds updated SPDX license IDs and exceptions (v3.28.0) and adds URL-to-ID resolution for common license sources, improving the accuracy and compliance of license identification in SBOM reports.
pkg/licensing/expression · high confidence
Logging subsystem migrated to Go's slog with context-aware prefixes and deferred output
The logging implementation in pkg/log has been replaced with a new handler built on Go's standard log/slog package. This change introduces context-aware logging, allowing prefixes and attributes to be attached via context (WithContextPrefix, WithContextAttrs) for better traceability. It also adds a deferred handler that buffers log messages before the logger is fully initialized, ensuring no logs are lost during startup. The new handler supports colored output for different log levels and provides a Fatal level that forces output to stderr.
pkg/log · high confidence
Migrate report writers to a Go-based implementation
The report output logic in pkg/report has been rewritten in Go, replacing the previous template-based approach with dedicated writer structs (JSONWriter, SarifWriter, TemplateWriter) and a central Writer interface. This change introduces new options for the JSON output to optionally include all packages (ListAllPkgs) and suppressed vulnerabilities (ShowSuppressed), and it enforces the removal of network access (getHostByName) from custom report templates for security. The SARIF writer now generates reports directly via code, ensuring stable identifiers and correct URI handling, while the template writer retains Sprig function support for user-defined formats.
pkg/report · high confidence
NPM version comparison now supports build metadata and pre-release versions
The NPM library detector now uses a dedicated comparer that correctly handles pre-release tags (e.g., -alpha, -lts) and optional build metadata (e.g., +build.1) when matching advisory constraints. This ensures that versions with build metadata are ordered and compared according to node-semver rules, preventing false negatives where a patched version with build metadata might otherwise be incorrectly flagged as vulnerable or vice versa.
pkg/detector/library/compare/npm · high confidence
New Azure ARM template parser with native JSON v2 support
The Azure ARM scanner now uses a completely rewritten parser located in \pkg/iac/scanners/azure/arm/parser\. This new implementation migrates from the previous custom JSON parsing logic to Go's \encoding/json/v2\ (via \json/jsontext\), enabling more robust handling of ARM templates. A key behavioral improvement is the support for ARM resources defined as objects (e.g., in language v2 templates), in addition to the traditional array format. The parser now correctly extracts metadata, parameters, variables, and resources into a standardized \azure.Deployment\ structure, allowing the scanner to analyze templates with richer context and better error handling.
pkg/iac/scanners/azure/arm/parser · high confidence
New CycloneDX SBOM marshaler and decoder implementation
The CycloneDX SBOM generation and parsing logic in \pkg/sbom/cyclonedx\ has been replaced with a new implementation. The new \marshal.go\ introduces a \Marshaler\ that converts Trivy reports into CycloneDX BOMs using an intermediate representation, ensuring sorted components and dependencies, and correctly handling empty slices and root components. The new \unmarshal.go\ provides a \BOM\ type that decodes CycloneDX JSON files into Trivy's internal BOM structure, supporting third-party SBOMs and external references. This change is accompanied by extensive test coverage in \marshal\_test.go\ and \unmarshal\_test.go\, along with numerous test data fixtures in \testdata/happy/\ covering various scenarios like nested packages, OS-only scans, and invalid inputs.
pkg/sbom/cyclonedx · high confidence
New Java JAR dependency parser with license detection
The Java JAR dependency parser has been rewritten to improve artifact identification and license detection. It now reads artifact properties strictly from the MANIFEST.MF main section, resolves JAR licenses from embedded pom.xml files, packaged LICENSE files, and Jenkins plugin manifests, and converts license URLs to SPDX IDs. The parser also deduplicates packages using go-mvn-version and sets per-file digests for nested JARs.
pkg/dependency/parser/java/jar · high confidence
New Terraform evaluation context wrapper with safe marked-value handling
A new Context wrapper for HCL evaluation has been introduced in pkg/iac/terraform/context to manage variable scopes and nested contexts. This component provides methods to get, set, and merge variables using dot-notation paths, ensuring that existing values are preserved during updates. Crucially, it implements logic to unmark cty values before traversal and restore marks afterward, preventing panics that occur when go-cty attempts to traverse marked values, thereby stabilizing the evaluation of sensitive or annotated data.
pkg/iac/terraform/context · high confidence
New license classification and scanning engine
The licensing package has been replaced with a new implementation that introduces a \Scanner\ for categorizing licenses (e.g., Forbidden, Restricted, Permissive) based on configurable categories and severity levels, and a \Classifier\ that uses the \github.com/google/licenseclassifier/v2\ library to detect and classify license text from files with a configurable confidence threshold. This change also includes a comprehensive license normalization layer (\normalize.go\) that maps various license name variations to standard SPDX identifiers and supports compound license expressions (AND/OR/WITH operators), along with updated test coverage for these new components.
pkg/licensing · high confidence
New npm lockfile parser with support for v1/v2/v3 formats and modern npm features
The npm dependency parser has been rewritten to support package-lock.json versions 1, 2, and 3, including handling of workspaces (as both arrays and objects), peer dependencies, and legacy license formats. The parser now correctly resolves package links, handles broken links without infinite loops, and merges indirect/dev/external reference fields for duplicate dependencies. It also supports boolean 'resolved' fields (e.g., 'false' for bundled dependencies) and extracts license information from lockfiles.
pkg/dependency/parser/nodejs/npm · high confidence
New secret analyzer implementation with binary and skip-pattern support
The secret scanning capability in the fanal analyzer has been replaced with a new implementation that introduces support for scanning specific binary files (such as Python .pyc files) by extracting printable bytes, adds a warning for files exceeding 10MB to prevent high memory consumption, and allows users to configure custom skip patterns (folders, files, and extensions) via the secret scanner configuration. The analyzer now correctly handles path normalization for image scans and ensures the configuration file itself is excluded from scanning.
pkg/fanal/analyzer/secret · high confidence
Node.js analyzer now skips invalid subdirectory package.json files
The Node.js package analyzer has been updated to silently skip package.json files located in subdirectories of installed packages (such as node\_modules/rxjs/ajax/package.json) that do not represent top-level package roots. This prevents false positives where bundler resolution hints or subpath helpers are incorrectly identified as distinct npm packages, ensuring that only valid, top-level package definitions are analyzed.
pkg/fanal/analyzer/language/nodejs/pkg · high confidence
OS package scanner now forwards detector options
The OS package scanning logic in pkg/scan/ospkg has been refactored to accept and forward configuration options (such as custom drivers) from NewScanner down to the underlying ospkgDetector. This ensures that specific detector behaviors configured at the scanner level are correctly applied during vulnerability detection, rather than being ignored or hardcoded.
pkg/scan/ospkg · high confidence
Poetry analyzer now distinguishes direct, indirect, and dev dependencies
The Poetry post-analyzer has been updated to parse \pyproject.toml\ alongside \poetry.lock\, enabling it to accurately classify packages as direct, indirect, or development dependencies. This change improves the dependency tree visibility for Python projects managed by Poetry, allowing users to better understand which packages are explicitly required versus those pulled in transitively or for development purposes.
pkg/fanal/analyzer/language/python/poetry · high confidence
Process-safe temporary file handling and traversal-resistant directory roots
The \pkg/x/os\ package now provides process-specific temporary directories that use random suffixes instead of PIDs, preventing collisions in environments like Kubernetes where multiple processes may share the same PID 1. This ensures that temporary files and directories created via \CreateTemp\ and \MkdirTemp\ are isolated per process and can be safely cleaned up with \Cleanup\. Additionally, the package introduces a \Root\ type that wraps \os.Root\ to provide traversal-resistant directory access, rejecting paths that escape the root directory or point to symlinks outside the allowed scope, thereby enhancing security for file operations confined to specific directories.
pkg/x/os · high confidence
Python license detection now respects PEP 639 and classifier metadata
The Python packaging parser now prioritizes the \License-Expression\ field (per PEP 639) when present, and falls back to extracting licenses from \Classifier: License\ headers in METADATA and PKG-INFO files. It correctly handles multiple classifiers, ignores non-specific groupings like \OSI Approved\, and uses the \License-File\ field as a final fallback, ensuring more accurate license identification for Python dependencies.
pkg/dependency/parser/python/packaging · high confidence
RPC client retry logic and comprehensive data conversion
The RPC layer now includes a retry mechanism for HTTP requests that encounter unavailable errors, using exponential backoff to improve resilience during client/server communication. Additionally, the new convert.go module provides comprehensive serialization logic, mapping internal package, vulnerability, secret, and license data structures to the RPC protocol buffer format, ensuring that detailed metadata such as package identifiers, locations, layer information, and license categories are correctly transmitted between client and server.
pkg/rpc · high confidence
Red Hat vulnerability detection now uses binary package names and supports modular packages
The Red Hat scanner has been refactored to query the vulnerability database using binary package names rather than source package names, ensuring that advisories are matched against the actual installed binaries. It now correctly handles modular packages by adding the appropriate modular namespace (e.g., \nodejs:12::npm\) when querying the database. Additionally, the scanner deduplicates advisories by selecting the latest fixed version for each CVE-ID and supports architecture-specific filtering, while also cleaning generic repository suffixes from content sets to improve match accuracy.
pkg/detector/ospkg/redhat · high confidence
Redesigned IaC types with typed values and state merging
The internal IaC representation has been refactored to use a generic \BaseValue\[T\]\ type, replacing the previous untyped approach. This introduces strongly-typed wrappers for primitives (Bool, Int, String, Bytes, Time, Map) that carry metadata (source location, managed status, unresolvable flags) and support JSON serialization. A new \State\ struct in \pkg/iac/state\ aggregates provider-specific data (AWS, Azure, Kubernetes, etc.) and includes a \Merge\ method to combine scanned states, preferring data from the second state when conflicts occur. Additionally, \State\ now exposes a \ToRego\ method to convert the entire scanned state into a format suitable for Rego policy evaluation.
pkg/iac/types · high confidence
Refactored OS package detection to use a driver-based architecture with third-party package filtering
The OS package vulnerability detector has been restructured to use a pluggable driver interface, allowing specific OS families (such as CoreOS, Bottlerocket, AlmaLinux, and others) to be handled by dedicated scanner implementations. This change introduces a new \Driver\ interface and a \Supplier\ mechanism that allows external or curated feeds (like RapidFort, Root.io, and Seal) to intercept and override the default detection logic. A key behavioral change is the automatic filtering of third-party packages (e.g., from EPEL or Docker) during detection to prevent false positives from vendor advisories that do not cover them; drivers can opt out of this filtering if their own advisory feeds cover those packages. The \gpg-pubkey\ package is now explicitly skipped as it lacks a real version for matching.
pkg/detector/ospkg · high confidence
Refactored downloader with ETag support and concurrency safety
The downloader package has been rewritten to support conditional HTTP requests via ETags, allowing the system to skip re-downloading content when the server returns a 304 Not Modified response. This change introduces a backup-and-restore mechanism for destination files to ensure data integrity during downloads and includes fixes for concurrent access to global maps and proper handling of the --insecure flag for HTTPS connections.
pkg/downloader · high confidence
Refactored filesystem walker with file caching and unified skip-path logic
The filesystem walker in \pkg/fanal/walker\ has been refactored to improve performance and consistency. A new \cachedFile\ mechanism caches small files in memory and writes large files (over 100MB) to temporary storage, reducing redundant I/O during analysis. The \FS\ walker now normalizes \--skip-dirs\ and \--skip-files\ paths relative to the root, correctly handling absolute, relative, and working-directory-based inputs. Additionally, the tar walker now explicitly skips symlinks and hardlinks, and the VM walker supports direct filesystem access with similar caching and skip-path logic.
pkg/fanal/walker · high confidence
Refactored main entry point to support plugin mode and graceful shutdown
The cmd/trivy/main.go entry point has been rewritten to explicitly handle two new operational modes: running as a Trivy plugin (triggered by the TRIVY\_RUN\_AS\_PLUGIN environment variable) and graceful shutdown via signal handling. The new code initializes the logger conditionally for plugins, delegates execution to the plugin runner when in plugin mode, and sets up a notify context for clean shutdown in standard mode, while also ensuring cleanup on exit.
cmd · high confidence
Refactored vulnerability severity selection and added primary URLs
The vulnerability client now implements a configurable severity selection strategy that prioritizes vendor-specific scores (such as Red Hat, NVD, or GHSA) over generic database values, with a fallback to UNKNOWN if no severity is found. It also automatically assigns a PrimaryURL to detected vulnerabilities based on their ID type (e.g., CVE, GHSA, RUSTSEC) or the originating data source, improving traceability for users.
pkg/vulnerability · high confidence
Register sysfile and unpackaged handlers via import alias
The handler registration mechanism in pkg/fanal/handler/all now explicitly imports the sysfile and unpackaged handler packages using blank identifiers. This ensures these specific analyzers are initialized and available for use, supporting the detection of vulnerabilities in non-packaged binaries and system files.
pkg/fanal/handler/all · high confidence
Rego scanner rewritten for OPA v1 with embedded check fallback
The IaC Rego scanner has been rewritten to use the OPA v1 API, introducing a new module loading and filtering pipeline. Embedded checks from trivy-checks are now loaded as a fallback when external policies fail to compile, ensuring scanning continues even if a specific check is incompatible with the current Trivy version. The scanner now supports configurable error limits, minimum Trivy version requirements for checks, and the ability to disable deprecated checks. Additionally, it provides a provider interface to inject a pre-configured Rego scanner into the IaC scanning workflow.
pkg/iac/rego · high confidence
Secret scanner refactored with streaming, Aho-Corasick keyword indexing, and new built-in rules
The secret scanning engine in \pkg/fanal/secret\ has been significantly restructured to improve performance and detection coverage. The scanner now uses a streaming approach with configurable buffer sizes (default 64KB) and overlap (4KB) to handle large files efficiently while detecting secrets spanning chunk boundaries. A new Aho-Corasick automaton (\keyword.go\) replaces per-rule keyword searches, allowing a single pass to identify candidate rules based on ASCII-case-insensitive keyword matching, which reduces memory usage and CPU overhead. The built-in rule set (\builtin-rules.go\) has been expanded to include detection for GitHub fine-grained PATs, GitHub App installation tokens (including the new stateless \ghs\_\ format), Hugging Face access tokens, Azure secrets, OpenAI keys, Symfony secret keys, Maven credentials, and Private Packagist tokens. Additionally, a new \builtin-allow-rules.go\ file centralizes path-based exclusions (e.g., \.dist-info\, \vendor\, \node\_modules\, test files) and supports disabling them via configuration. The scanner also now validates UTF-8 content to prevent marshalling errors and supports customizable skip patterns, allow rules, and exclude blocks via YAML configuration.
pkg/fanal/secret · high confidence
Standardized dependency identification and unique ID generation
The dependency analysis engine now uses a unified, language-specific format for constructing unique package IDs in the dependency graph. The new \ID\ function applies distinct separators per ecosystem: slash (\/\) for Conan and .NET, colon (\:\) for Java-based tools (Maven, Gradle, SBT), and at-sign (\@\) for Go, Python, and others, while ensuring Go versions always retain the \v\ prefix. Additionally, a new \UID\ function generates stable, hash-based unique identifiers for packages, prioritizing explicit package UIDs when available and falling back to a hash of the file path and package metadata to ensure uniqueness across different locations.
pkg/dependency · high confidence
Sync Terraform parser functions with upstream Terraform
The Terraform parser's built-in functions (such as CIDR, collection, crypto, datetime, encoding, filesystem, IP, string, and sensitive handling) have been replaced with versions copied directly from the upstream HashiCorp Terraform repository. This synchronization ensures that the scanner's expression evaluation aligns with current Terraform behavior, including updated logic for file operations, cryptographic hashing, and type conversions.
pkg/iac/scanners/terraform/parser/funcs · high confidence
Terraform configuration parser refactored and expanded
The internal Terraform configuration parser has been rewritten to improve accuracy and support newer HCL features. The new implementation correctly handles HCL object expressions by returning proper references instead of raw values, and it now supports the OpenTofu 'language' block for compatibility constraints. Schema coverage has been expanded to include 'ephemeral', 'action', and 'removed' blocks, while preset generation now automatically creates placeholder values for 'random' provider resources to prevent evaluation errors. Additionally, the parser safely handles null and unknown cty values to prevent panics during attribute access.
pkg/iac/terraform · high confidence
Terraform scanner restructured with new options API and enhanced ignore capabilities
The Terraform scanner has been refactored to use a new \options.ScannerOption\ pattern, introducing explicit configuration functions such as \ScannerWithSkipFiles\, \ScannerWithSkipDirs\, and \ScannerWithSkipCachedModules\ for better control over scanning behavior. This change also introduces support for ignoring resources by nested attributes (e.g., \// %s:ignore:\*\[versioning.enabled=false\]\) and adds comprehensive tests for inline ignore rules, JSON configuration scanning, and policy namespace filtering.
pkg/iac/scanners/terraform · high confidence
Unified Kubernetes manifest parser with accurate line tracking
The Kubernetes scanner now uses a new parser in \pkg/iac/scanners/kubernetes/parser\ that handles both JSON and YAML manifests through a single entry point. It correctly splits multi-document YAML files (separated by \---\) and adjusts line numbers so that diagnostics point to the exact location in the original file. The parser preserves YAML-specific tags (such as \!!timestamp\, \!!binary\, and \!!float\) and retains \null\ values in the parsed structure, ensuring that Rego-based checks receive complete and accurately located manifest data.
pkg/iac/scanners/kubernetes/parser · high confidence
Unified OS release detection via os-release analyzer
The system now uses a single \os-release\ analyzer to detect the operating system family and version across a wide range of Linux distributions. This change consolidates support for diverse platforms—including Bottlerocket, Azure Linux (Mariner), Chainguard, ActiveState, Wolfi, MinimOS, Echo, CoreOS, and SUSE Linux Enterprise Micro—into one detection mechanism. It also improves accuracy for existing distributions by correctly distinguishing CentOS Stream from standard CentOS and handling RHEL-based images, ensuring more reliable vulnerability scanning for these environments.
pkg/fanal/analyzer/os/release · high confidence
Unified artifact scanning entry point with client/server mode support
The artifact scanning logic is now centralized in the \pkg/commands/artifact\ package, introducing a \Runner\ interface that manages the lifecycle of scans across all target types (container images, filesystems, repositories, SBOMs, and VMs). This change consolidates initialization steps—such as vulnerability database updates, VEX repository downloads, and WASM module loading—into a single entry point. It also explicitly supports both standalone and client/server scanning modes, allowing users to route scan data to a remote Trivy server via dedicated remote scan service functions while maintaining the same unified interface for local operations.
pkg/commands/artifact · high confidence
Unified cache interface with filesystem, memory, and Redis backends
The scan cache system has been refactored to use a single \Cache\ interface that supports multiple storage backends. Users can now choose between a local filesystem cache (using BoltDB), an in-memory cache for testing or short-lived scans, and a Redis cache for shared or persistent storage. The \pkg/cache\ package centralizes this logic, providing a factory function to initialize the appropriate backend based on configuration, while also introducing a cache key calculation mechanism that accounts for analyzer versions, policy paths, and detection priority to ensure cache validity.
pkg/cache · high confidence
Unified image loading with explicit source selection and archive support
The image loading logic has been restructured to support explicit selection of image sources (Docker, Podman, containerd, or remote registry) via a new \ImageSources\ option, allowing users to specify which runtime(s) to use. The system now natively supports loading images from local Docker and OCI archives, correctly extracting repository tags from Docker archives while handling OCI layouts. Additionally, remote image retrieval now rejects unsupported artifact types (such as Helm charts) that are not valid container images, and the base layer detection logic has been updated to improve accuracy for CIS scanning.
pkg/fanal/image · high confidence
Unified infrastructure-as-code file detection system
The IaC scanning engine now uses a centralized detection package to identify file types before scanning. This change introduces support for new formats including OpenTofu (.tofu), Ansible, and Terraform Plan snapshots (both JSON and binary), while also adding generic YAML and JSON detection. The system now leverages the Helm SDK for parsing Helm charts and uses the google/jsonschema-go library for schema validation, replacing previous custom parsers and dependencies.
pkg/iac/detection · high confidence
Unified registry token retrieval with pluggable provider support
The registry authentication logic has been refactored to use a centralized token retrieval mechanism that iterates through registered providers (Google, ECR, Azure) to find credentials matching the target domain. This change introduces a pluggable architecture where new registry types can be added via the \RegisterRegistry\ function, and the \GetToken\ function now handles credential lookup and error logging consistently across all supported cloud registries.
pkg/fanal/image/registry · high confidence
Unified result filtering with .trivyignore.yaml and Rego policy support
The \pkg/result\ package now provides a centralized filtering mechanism for vulnerabilities, misconfigurations, secrets, and licenses. Users can ignore findings using the existing \.trivyignore\ file or a new structured \.trivyignore.yaml\ configuration that supports specific categories, path patterns, package URLs (PURLs), and expiration dates. Additionally, filtering can be customized via Rego policy files, allowing users to define complex logic for including or excluding findings based on their properties.
pkg/result · high confidence
Version endpoint now excludes JavaDB and CheckBundle in server mode
The version information logic has been updated to distinguish between client and server modes. When the server option is enabled, the version info returned by the /version endpoint no longer includes JavaDB or CheckBundle metadata, as these components are managed on the client side in client/server deployments. This ensures that server responses only reflect data relevant to the server's own state, preventing confusion about database synchronization status.
pkg/version · high confidence
Version-specific documentation URLs
Documentation links now point to versioned paths on trivy.dev (e.g., docs/v0.52) instead of a single generic location. Pre-release and development versions resolve to the docs/dev path, ensuring users always see documentation that matches their installed version.
pkg/version/doc · high confidence
Fixes
Fix Bitnami vulnerability detection using correct version comparison
The vulnerability detection logic for Bitnami packages now uses a dedicated comparer that correctly parses and compares versions, including those with revision suffixes (e.g., 1.2.3-1). This ensures that advisory constraints are evaluated accurately against installed package versions, preventing false positives or negatives in vulnerability reporting.
pkg/detector/library/compare/bitnami · high confidence
Introduce Registry interface for credential retrieval
A new Registry interface has been added to the fanal package, defining a contract for registry clients to retrieve credentials via a GetCredential method and for registries to validate options via CheckOptions. This abstraction enables the underlying implementation to handle specific registry providers, such as AWS ECR across different regions, by decoupling credential logic from the core image analysis flow.
pkg/fanal/image/registry/intf · medium confidence
Terraform parser rewritten with improved module resolution and security hardening
The Terraform parser in \pkg/iac/scanners/terraform/parser\ has been completely rewritten to improve stability, security, and OpenTofu compatibility. The new implementation introduces a sandboxed filesystem for HCL functions to prevent path traversal attacks, adds support for OpenTofu language blocks and file extensions, and fixes critical issues with module caching, submodule evaluation, and dynamic block expansion. It also includes a new \ctylist\ utility for safe tuple manipulation and comprehensive tests for variable loading and root module discovery.
pkg/iac/scanners/terraform/parser · high confidence
Updated npm conversion test fixtures with package UIDs and suppressed findings
The integration test fixtures for npm conversion have been updated to reflect changes in how packages are identified and how findings are reported. The new \npm-with-suppressed.json.golden\ fixture demonstrates the inclusion of unique package UIDs in the \Identifier\ field for both packages and vulnerabilities, ensuring precise matching. It also includes an \ExperimentalModifiedFindings\ array, showing how suppressed or modified findings (such as those marked as \not\_affected\) are now structured in the output. The \npm.json.golden\ fixture remains consistent with previous structures but serves as a baseline for these conversion tests.
integration/testdata/fixtures/convert · high confidence
Test coverage
Add Kubernetes integration test fixtures for limited namespace and RBAC scenarios; Added CycloneDX SBOM test fixtures for v1.5 and in-toto attestation support; Added Docker integration test helper for image replication; Added NuGet package metadata test fixtures for license support; Added SBOM test fixtures for CycloneDX and SPDX formats; Added cryptographic asset fixtures for testing; Added end-to-end testing framework for image scanning and proxy scenarios; Added integration tests for fanal library and containerd scanning; Added internal cache testing utilities; Added internal test hook for validating extension lifecycle; Added test data for nested and local Terraform modules; Added test fixtures for Go module parsing edge cases; Added test fixtures for Terraform Plan snapshot scanning; Added test fixtures for cached modules, nested structures, and tfvars; Added test fixtures for ignore rules and VEX support; Added test plugin fixtures for plugin validation; Added test utility for creating Terraform modules from source; Added tests for CloudFormation scanning; Added tests for compliance spec loading and result mapping; New CloudFormation test utility for adapter validation; New integration test framework with golden file management; New internal test utilities for Docker, filesystems, and scan assertions; New internal test utilities for OCI registry operations; New test helper for ARM adapter validation; New test server package for attestation validation; New test utilities for multi-database and OCI artifact mocking; Updated Python package metadata test fixtures; Updated integration test golden files for AlmaLinux 8 and Alpine 3.10; Updated package analysis golden files for integration tests; Updated test golden files for Ruby dependency analysis.
Dependencies
Routine dependency updates across 265 manifests
This release updates dependencies across 265 manifests, including bumps to the Go toolchain (versions 1.15 through 1.24.7), AWS SDKs, Docker libraries, and various Go modules. These changes maintain compatibility with newer Go versions and update underlying libraries to their latest stable releases.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 63 → 64 (+1.5)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 76 → 76 (-0.0)
- Architecture 87 → 95 (+8.0)
- Maturity 73 → 71 (-2.7)
- Readiness 49 → 52 (+2.8)
- Security 73 → 73 (-0.1)
- Performance 75 → 90 (+15.4)
Resolved (29)
- Duplicated block (11 lines × 2) (pkg/cache/fs.go)
- Duplicated block (12 lines × 2) (pkg/fanal/analyzer/language/c/conan/testdata/cacheDir/.conan/data/openssl/3.0.5///export/conanfile.py)
- Duplicated block (6 lines × 2) (pkg/detector/ospkg/alma/alma.go)
- Duplicated block (6 lines × 2) (pkg/fanal/analyzer/language/c/conan/testdata/cacheDir/.conan/data/openssl/3.0.5///export/conanfile.py)
- Duplicated block (7 lines × 2) (pkg/fanal/analyzer/language/c/conan/testdata/cacheDir/.conan/data/openssl/3.0.5///export/conanfile.py)
- Duplicated block (8 lines × 2) (pkg/fanal/analyzer/language/c/conan/testdata/cacheDir/.conan/data/openssl/3.0.5///export/conanfile.py)
- Duplicated block (8 lines × 2) (pkg/iac/scanners/terraform/parser/funcs/encoding.go)
- Hotspot: pkg/dependency/parser/java/jar/parse.go (pkg/dependency/parser/java/jar/parse.go)
- Hotspot: pkg/dependency/parser/java/pom/parse.go (pkg/dependency/parser/java/pom/parse.go)
- Hotspot: pkg/fanal/types/crypto_descriptor.go (pkg/fanal/types/crypto_descriptor.go)
- Leaked secret: hardcoded-credential (integration/data/auth_config/config.yml)
- Leaked secret: hardcoded-credential (integration/data/auth_config/config.yml)
- Leaked secret: password-hash-credential (integration/data/auth_config/config.yml)
- Leaked secret: password-hash-credential (integration/data/auth_config/config.yml)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (pkg/detector/ospkg/azure/azure.go)
- Near-duplicate member pair (41 shared lines) (pkg/fanal/analyzer/language/c/conan/testdata/cacheDir/.conan/data/openssl/3.0.5///export/conanfile.py)
- No ADRs found
- Off-boarding risk: anonymized user #1
- Off-boarding risk: anonymized user #2
- Off-boarding risk: anonymized user #3
- …and 9 more
New (167)
- Duplicated block (12 lines × 2) (pkg/sbom/cyclonedx/unmarshal.go)
- Duplicated block (2–7 lines × 5) (pkg/detector/ospkg/alma/alma.go)
- Edited copies of one member (3 members, 13+ corresponding lines) (pkg/fanal/image/name/reference.go)
- Edited copies of one member (3 members, 13+ corresponding lines) (pkg/iac/adapters/cloudformation/aws/elb/loadbalancer.go)
- Edited copies of one member (3 members, 13+ corresponding lines) (pkg/sbom/sbom.go)
- Edited copies of one member (3 members, 14+ corresponding lines) (pkg/fanal/analyzer/pkg/apk/apk.go)
- Edited copies of one member (3 members, 14+ corresponding lines) (pkg/iac/terraform/attribute.go)
- Edited copies of one member (3 members, 15+ corresponding lines) (pkg/fanal/analyzer/language/golang/mod/mod.go)
- Edited copies of one member (3 members, 15+ corresponding lines) (pkg/iac/adapters/terraform/google/iam/project_iam.go)
- Edited copies of one member (3 members, 16+ corresponding lines) (pkg/iac/scanners/cloudformation/parser/property.go)
- Edited copies of one member (3 members, 20+ corresponding lines) (pkg/iac/adapters/terraform/azure/database/mariadb.go)
- Edited copies of one member (3 members, 25+ corresponding lines) (pkg/iac/scanners/ansible/parser/discovery.go)
- Edited copies of one member (3 members, 40+ corresponding lines) (pkg/fanal/analyzer/language/nodejs/bun/bun.go)
- Edited copies of one member (3 members, 9+ corresponding lines) (pkg/cache/remote.go)
- Edited copies of one member (4 members, 12+ corresponding lines) (pkg/iac/terraform/attribute.go)
- Edited copies of one member (4 members, 4+ corresponding lines) (pkg/fanal/analyzer/language/c/conan/testdata/cacheDir/.conan/data/openssl/3.0.5///export/conanfile.py)
- Edited copies of one member (4 members, 61+ corresponding lines) (pkg/commands/app.go)
- Edited copies of one member (5 members, 33+ corresponding lines) (pkg/fanal/analyzer/language/julia/pkg/pkg.go)
- Edited copies of one member (6 members, 10+ corresponding lines) (pkg/commands/artifact/scanner.go)
- Edited copies of one member (6 members, 8+ corresponding lines) (pkg/fanal/analyzer/language/dotnet/deps/deps.go)
- …and 147 more
Changes since last survey
- 30 commits — 20 feature/other, 10 fixes
By area
- docs/guide — 6 commits
- pkg/crypto — 5 commits
- pkg/fanal — 5 commits
- pkg/dependency — 4 commits
- (root) — 3 commits
- pkg/detector — 3 commits
- helm/trivy — 1 commit
- pkg/result — 1 commit
- pkg/sbom — 1 commit
- pkg/vex — 1 commit
Notable commits
- fix: fix(containerd): export image by its stored name (#11511)
- fix: fix(license): categorize MIT-0 as unencumbered (#11498)
- fix: fix(nodejs): derive Bun package name and version from the identifier (#11071)
- fix: fix(nodejs): match npm link targets on a path boundary (#11495)
- fix: fix(nodejs): read yarn.lock block fields by indent level (#11496)
- fix: fix(oracle): add Oracle Linux 10 EOL date (#11601)
- fix: fix(rocky): add Rocky Linux 10 EOL date (#11531)
- fix: fix(rust): retain direct dependencies declared without version (#11248)
- fix: fix(sbom): preserve third-party repository class in SBOM (#11466)
- fix: fix(swift): trim a trailing slash from a Package.resolved location (#11580)
- change: chore(deps): bump alpine to 3.24.3 in container images (#11468)
- change: chore(deps): bump github.com/go-jose/go-jose/v4 from 4.1.5 to 4.1.6 (#11488)
- change: chore(deps): bump golang.org/x/net from 0.61.0 to 0.62.0 (#11489)
- change: ci(helm): bump Trivy version to 0.76.2 for Trivy Helm Chart 0.28.2 (#11558)
- change: docs(crypto): clarify cryptographic asset scanning limitations (#11378)
- change: docs(go): describe which go.mod directive sets the stdlib version (#11583)
- change: docs(python): add pylock.toml row to language coverage index (#11584)
- change: feat(crypto): add check for small EC private keys (#11479)
- change: feat(crypto): read certificates from JKS keystores (#11400)
- change: feat(crypto): report private keys from PKCS#12 and JKS keystores (#11524)
- …and 10 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
aquasecurity/trivy was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 6cd398d59b7f9e3bed6d6f11670dc79f3b443245 — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.