Skip to content

fleetreach 1.6.0

Choose a tag to compare

@github-actions github-actions released this 05 Nov 07:18
· 208 commits to main since this release

Added

  • SBOM input matches OS packages. pkg:deb, pkg:apk and pkg:rpm components go to the same
    distro matchers as an image, so a Syft or Trivy image SBOM scans in full. The release comes from
    the distro qualifier or the operating-system component, and each package's source from what
    the tool wrote. A document that names no release, or several, is a coverage gap, and so is one
    that names no source packages. SPDX has no module stream labels, so on a Red Hat module build
    the scan says it may differ from the image.

  • fix plan reads each repo's ranges before it proposes a target, for npm's
    package-lock.json and for Cargo. A target your own manifest leaves out is a new
    manifest-bump edit: fix apply raises the range, an exact pin included, then updates the
    lock. A target a published package leaves out, peer ranges included, is blocked and names the
    package to update first, rather than failing in fix apply.

  • fix plan keeps targets clear of advisories of their own. The queue only knows the
    advisories some repo already has, so a target could carry one that starts above every installed
    version, and the re-scan then refused the bump. The plan now reads the OSV exports (--osv-dir,
    or wherever a scan finds them) and moves the target to the lowest fix that adds nothing. This
    also restores Maven's four-part fixes such as 3.41.2.2, which the plan had cut to a version
    that does not exist.

  • scan --reachability builds witness chains for Ruby, PHP, .NET, Java and Kotlin, Elixir and
    Swift.
    A chain starts at the import line in your source and follows the lockfile, for example
    imported at app/models/user.rb:3 via loofah → nokogiri. Positive-only, like Python's. JSON
    reports the line as reachability.import_site.

  • SARIF codeFlows follow import chains, for npm and Python too, and start at the import line
    where it is known.

  • licenses --detect reads the license files packages ship, with the spdx crate's own
    matcher over the SPDX texts, in pure Rust, on this machine. A package nothing declared takes
    the license its files say, unless one of them could not be recognized. A package whose files
    name a license its declaration does not account for is a mismatch, with its verdict in
    [settings.licenses] mismatch.

  • licenses --detect --download reads packages that are not on this machine. It fetches each
    public package's archive for npm, Cargo, PyPI, RubyGems, Hex and Go, checks it against the
    lockfile's hash (the tree hash in go.sum for Go), and keeps only its license files in a cache
    keyed by that hash, which --detect then reads offline.

  • SBOM input takes CycloneDX XML, SPDX tag-value and GitHub's dependency graph export, and
    finds SBOMs by itself. [settings.sbom] discover scans the SBOMs in a repo with nothing else
    to read, [[repo]] sbom_discover sets that per repo, and [[source]] sbom_assets fetches
    those on the latest release on fleet sync (GitHub, Gitea, Forgejo). An SBOM older than the
    newest lockfile commit is a coverage gap.

  • pkg:golang and pkg:cargo in an SBOM are now matched, with RustSec and the crates.io
    export for Rust. Go names compare without case where a purl lost it, as Trivy's do. Direct
    dependencies are found below the lockfile and project nodes Trivy puts under the root, in
    every ecosystem.

  • scan --health asks registries what a lockfile cannot show: npm and NuGet deprecations,
    PyPI, RubyGems, crates.io and NuGet yanks, Packagist abandoned with the replacement, Go
    deprecations and retractions, Hex retirements and Maven relocations, plus archived GitHub
    repos with a token and low OpenSSF Scorecards with [settings.health] min_scorecard. Only
    public packages are sent, and answers are cached for a week. A package with no answer is a
    coverage gap, never clean.

  • Scope for Cargo, Bundler, Hex, NuGet and Go, and a gate per scope. A package only dev
    dependencies lead to is now scope: dev in these five too, so --ignore-dev-deps, SBOM
    scope: excluded and license scope = "runtime" cover them. --fail-on-dev and
    [settings.gate.scope] dev give dev packages their own floor, or never; diff --base takes
    the flag. Known malware keeps the runtime floor. Whatever cannot be read stays runtime: against
    cargo tree, go list, Bundler and mix deps on real repos, no package those tools ship was
    called dev. Go needs the dependency source, so run go mod download first. See "Gate on what
    ships".

  • diff --base <ref> says what a change brought in. New findings are compared per
    occurrence and placed by git: brought in, with the lockfile line and the manifest line that
    caused it; already at the merge base, so the advisory is what changed, which no longer
    gates; or not placed, which still gates. Fixture PRs from real lockfiles passed on all twelve
    ecosystems.

  • SARIF regions now also cover gradle.lockfile, packages.config, pylock.toml and
    requirements files under other names.

  • Five more [[source]] kinds: gitea, forgejo, bitbucket (Cloud), bitbucket-server
    (Data Center) and azure (Azure DevOps). topics on a forge without topics is a config
    error. Listings refuse a next link off the API, a pager that repeats, and Azure's redirect
    to sign-in. A sync without a token now says that only public repos were listed.

  • fleet sync and scan --sync report the repos added, removed and renamed since the last
    listing, by the forge's own repo id, and --history-dir appends them to inventory.jsonl.

  • SSL_CERT_FILE sets the trusted roots for forge listings, for a forge behind a private CA.

  • A repo with nothing fleetreach reads now says "no recognized lockfile or manifest", not "no
    Cargo.lock found".

  • scan --incremental reuses a repo's findings while the binary, the advisory data for its
    ecosystems and the files a scan reads are unchanged, and skips loading the advisory data of any
    ecosystem with nothing to re-scan. On 10,471 repos a warm run took about half the time and a
    third of the memory, with byte-identical output. A fleet of a few large monorepos gains
    nothing; see the new scale benchmark page. Maven, Gradle, SBOM inputs and govulncheck are
    never reused.

  • db sync updates an export record by record. It reads the ecosystem's modified_id.csv,
    fetches only the changed records and rewrites all.zip, instead of downloading the whole zip
    again. A cache five days old took 8 seconds, against 300 MB before. Every one of 329,822
    records then matched a fresh download byte for byte, and a 121-repo scan came out identical.
    Anything doubtful falls back to the whole export; --force always downloads it. Releases
    like Debian:12 have no listing on osv.dev and stay whole downloads.

  • db snapshot and --db-snapshot pin a run. The manifest hashes every source; a pinned
    scan is offline and exits 2 unless the directory holds exactly those files.

  • db bundle and db import --bundle carry all the advisory data in one tar: OSV and
    distro exports, RustSec, KEV, EPSS, CVE and CSAF indexes, and the NVD and Vulnrichment caches.
    db sync --source gains rustsec, kev, epss, nvd and vulnrichment. An imported
    scan with --enrich matched the online one on 1,182 findings, run with network access denied,
    and 44 images matched on 19,286 findings.

  • scan --offline --enrich reads KEV, EPSS, NVD scores and Vulnrichment from the data directory.

  • --db on a RustSec clone reports its commit, so --max-db-age works there. It used to be
    unknown.

  • fix apply handles pnpm, yarn, Composer, Bundler, NuGet and Maven. Lockfile managers
    update with scripts and plugins off; NuGet and Maven change the declared version, or the
    property it reads. Checked on 30 throwaway repos across all twelve update paths: 28 edits
    verified, and every changed lockfile passed the package manager's frozen install.

  • fix apply keeps its pull requests current. A re-run leaves a branch verified on the
    current base alone, rebuilds a stale one, and skips closed or merged requests and branches
    someone else pushed to. --close-obsolete closes requests the plan no longer wants, only
    in repos it scanned.

  • fix apply --max-prs, --canary and --stop-after-failures limit a rollout.

  • Gradle builds without a lockfile are scanned. They were skipped before. Version catalogs
    and literal declarations resolve through the POM resolver, with the highest version winning,
    and the result is always marked partial. Against real Gradle, 163 of 173 packages matched on
    Spring PetClinic, 17 of 18 on Aeron and 71 of 109 on the Airflow Java SDK.

  • Releases add static musl builds for Linux x86-64 and ARM64, and a Windows ARM64 build. The
    install script picks musl on Alpine.

  • pnpm-lock.yaml version 5 is read, and a catalog: dependency is proven to use the version
    its importer records. Across 39 real lockfiles, the package sets match pnpm list, yarn list,
    yarn info and bun pm ls on 35; the other four are explained in
    docs/specs/16-a-plus.md.

  • SBOM components carry hashes from the lockfile: Cargo, npm, pnpm, yarn v1, bun, Bundler, mix,
    uv, Poetry, pylock and Composer. Sampled against registry downloads: 442 hashes across ten
    lockfile formats, all matching. NuGet's contentHash is left out, since it skips the package
    signature and matched none of 25 downloads.

  • sbom writes CycloneDX 1.7 by default, with --cyclonedx-version 1.6 on request, and XML
    with -f cyclonedx-xml. All 121 test BOMs pass the official schemas in both versions, the XML
    holds the same content as the JSON, and Grype and Trivy read them.

  • CI runs the whole test suite in a network namespace with no route out, so a test or feature
    that needs the network fails the build.

  • ci/fleetreach.gitlab-ci.yml, a template a GitLab pipeline can include to scan a repo and keep
    the SARIF.

  • SARIF results point at the package's line in its lockfile, and carry the dependency chain as
    codeFlows. A package whose line cannot be found keeps a file-level location. Checked on 30
    repos and 600 real lockfiles: the output passes the SARIF 2.1.0 schema, and every line named
    holds its package.

  • history epss flags open advisories whose EPSS rose by 0.1 or entered the top 5%, and exits 1
    on any. Findings now carry epss_percentile. Checked by replaying 31 days of real EPSS files
    against a frozen fleet.

  • scan --why --all-paths lists every path into a package, shortest first and capped by
    --max-paths. scan --versions <pkg> lists each version across the fleet with its repos.
    Both, and plain --why, take -f json.

  • [[settings.ignore]] takes expires and owner. After its last day an ignore stops
    hiding its finding, and the scan fails while the finding is open, as for triage decisions.

  • [[settings.context.tag_rules]] sets SSVC exposure and impact from repo tags and forge
    topics. The report's context[].set_by names the rule behind each value.

  • Triage files (spec 16, row 6). One decision per finding, in
    triage/<advisory>/<ecosystem>-<package>.toml beside fleet.toml: state (affected,
    in_triage, accepted_risk, false_positive, not_affected, fixed), assignee, expiry,
    justification, repos and an append-only log. Two people triaging different findings never
    touch the same file, so branches merge clean, and git is the audit trail. fleetreach triage set and list write and show them, and scan reads them: accepted_risk, false_positive
    and not_affected set a finding aside until they expire.
    An expired decision puts the finding back and fails the run. A file that cannot be read exits
    2. triage export -f openvex publishes the decisions, and Trivy and Grype honor them: an
    accepted risk is affected, never not_affected, so other tools keep reporting it.

  • Rust binaries in images are read: the crates cargo auditable lists in the binary are matched
    against RustSec, as Go binaries are against the Go database. A Rust binary with no such list
    is a coverage gap.

  • fleetreach scan without a fleet.toml scans the git work tree around the current
    directory as a one-repo fleet (a note on stderr says so); scan --repo <DIR> does the same
    for any directory. An explicit -c that does not exist is still an error.

  • Container images (spec 16, row 10, phase 1). [[image]] in fleet.toml (id, path,
    optional platform and distro, and the repo context fields) and scan --image <path>
    (repeatable; no fleet.toml needed) scan a docker save or OCI-layout tarball, an
    OCI-layout directory, or a root filesystem. Layers merge with OCI whiteouts, and layers
    named by digest are verified. Nothing in the image runs. The distribution comes from
    /etc/os-release: Debian, Ubuntu (with Ubuntu Pro for +esm packages), Alpine, Wolfi,
    Chainguard, MinimOS, Alpaquita, Echo, CleanStart, and Root's patched packages. dpkg
    status, distroless status.d and apk installed are read, each binary package matched
    under its source package against the osv.dev distro export, with dpkg's and apk-tools'
    version orderings. Unfixed Debian and Ubuntu advisories are findings marked no fix yet
    with their urgency; --distro-ignore-unimportant drops the unimportant and negligible
    ones. Lockfiles and installed Python and npm packages in the image go through the
    language matchers, skipping files an OS package owns. Fail-closed: an unreadable image or a
    missing distro export is an errored target, and an unknown distribution or release or an
    unreadable package database is a coverage gap. New crate fleetreach-os.

  • Registry pull (spec 16, row 10, phase 3; network build). --image docker://<reference>
    and ref = "..." in [[image]] pull from any OCI registry, with logins from Docker's config
    and credential helpers. The manifest, config and every layer are checked against their
    digests, a tag's digest is computed here and recorded in the report's provenance, and blobs
    are cached by digest, so a digest pulled before also scans with --offline. Logins go only
    to the registry and a token service on its domain, over TLS.

  • VEX attached to images (spec 16, row 10, phase 3). --vex-oci reads OpenVEX attestations
    on images pulled from registries: OCI 1.1 referrers, the referrers tag, and cosign's .att
    tag, on the image and its index. A document sets findings aside only when --vex-oci-key
    verifies its signature, or with --vex-oci-unsigned; others are listed in the report and
    change nothing. A document naming another image is refused. The latest statement decides,
    and a source package or a many-CVE advisory goes only when every binary and CVE is covered.

  • Go binaries, Composer and .NET in images (spec 16, row 10). Go binaries are read for their
    build info and matched as Go modules and stdlib. Composer's installed.json, .NET's
    .deps.json, any package.json and bare .egg-info files are read as installed packages.

  • Image differential (spec 16, row 10, phase 3). 217 public images against Trivy 0.73.0 and
    Grype v0.121.1, every difference in findings classified, in docs/differential.

  • Image layers and base images (spec 16, row 10, phase 3). Every finding in an image names
    the layer that put the package there, with its digest and build step, and whether it belongs
    to the base image. Where several images share a base, the report's base_images and the
    table's closing section say how many findings its layers hold and how many a rebuild can
    clear. Layers match Trivy 0.73.0 on Debian, Alpine and Rocky images.

  • Java archives and gems inside images (spec 16, row 10). .jar, .war, .ear, .par,
    .kar, .jpi and .hpi files are read through, nested archives included, and matched as
    Maven packages; installed gems (specifications/*.gemspec) are matched as RubyGems. An
    archive is identified by its pom.properties, by its file name with the group settled from
    its OSGi bundle name and class packages, or by its OSGi manifest. Nothing in an archive is
    run. An archive that cannot be placed is a coverage gap, never a guess. On Tomcat, Jenkins,
    Elasticsearch, Spring and Ruby images, every package Trivy 0.73.0 reports as vulnerable is
    reported, and fleetreach also reaches jars inside Jenkins plugins that Trivy does not.

  • rpm-based container images (spec 16, row 10, phase 2). Red Hat Enterprise Linux (UBI),
    AlmaLinux, Rocky Linux, openSUSE Leap and Tumbleweed, SUSE Linux Enterprise 15 and SLE
    Micro, Azure Linux and CBL-Mariner 2, Mageia and openEuler images are matched against their
    osv.dev exports. The rpm database is read in pure Rust in all three formats rpm has used
    (SQLite with its write-ahead log, Berkeley DB, NDB), with no rpm and no database library;
    an empty stray database beside the real one (Oracle Linux 9 ships one) is skipped, and two
    that disagree are a coverage gap. Versions compare with rpm's ordering (epoch, ~, ^).
    Red Hat and AlmaLinux advisories name binary packages, so there each binary is matched on
    its own; elsewhere binaries fold into their source rpm. AlmaLinux's bug fix and
    enhancement advisories (ALBA, ALEA) that name no CVE are not reported as vulnerabilities.
    Package names are <distro>/<package> (rocky-linux/openssl, redhat/openssl-libs),
    ecosystem rpm.

  • Vendor feeds for rpm distributions osv.dev lacks (spec 16, row 10, phase 2). Amazon
    Linux 2 and 2023 (the core repository's updateinfo.xml, the ALAS advisories yum updateinfo reads), Oracle Linux 7 to 10 (Oracle's OVAL, the ELSA advisories) and Photon OS
    3.0 to 5.0 (VMware's CVE metadata) are fetched from the vendor, converted to OSV records and
    cached like an osv.dev export, so their images are matched instead of being gaps. Findings
    link the vendor's advisory page. Oracle's advisories for a module stream match only
    packages from that stream (from the package's modularity label, or for an older build
    without one, the stream /etc/dnf/modules.d enables). Conversion is strict: a feed whose
    shape is not understood fails the sync rather than load partly. Validated against the
    distributions' own tools: equal to yum updateinfo list security on Amazon Linux 2 (261
    advisory and package pairs) and dnf updateinfo list --security on Amazon Linux 2023
    (260) and Oracle Linux 8 with module streams enabled (371 of 374; the other 3 are one ELSA
    Oracle's OVAL omits, a reissue whose CVEs a later ELSA in the feed covers), and to the raw
    Photon feed evaluated with rpm's comparator (252).

  • Bottlerocket (spec 16, row 10, phase 2). A Bottlerocket root filesystem is matched against
    Bottlerocket's own advisory feed (updateinfo.xml.gz, BRSA and GHSA advisories for every
    variant and version; db sync --distros Bottlerocket), with its packages read from
    /usr/share/bottlerocket/application-inventory.json, as Bottlerocket ships no rpm database.
    Both the bottlerocket- prefixed and the short package names in an advisory are matched, and
    epochs are kept, which Bottlerocket's switch from OS-release to upstream versions relies on.
    Findings link the advisory's page. Validated on 1.66.0 and 1.68.1: equal to the feed evaluated
    with rpm's comparator, and a superset of Trivy 0.73.0 (its 200 findings plus 130 kernel
    advisories its data does not carry yet).

  • Red Hat's unfixed CVEs in RHEL and UBI images (spec 16, row 10, phase 2). The CSAF VEX
    index (db sync --source csaf:redhat or db import --csaf) is turned into a per-release
    export on the first scan that needs it (about 20 seconds, then cached until the index
    changes) and consulted where the release's osv.dev records do not name a CVE for a package:
    CVEs Red Hat lists as affected, will not fix, fix deferred, out of support scope or under
    investigation become findings marked no fix yet with that status, and fixes on the
    release's main stream that osv.dev has not imported yet are reported with their version.
    Red Hat lists open CVEs by source package, so a binary package also matches its source
    package's open statuses, unless Red Hat says something about the binary itself (a binary
    it lists as not affected stays clean). Module streams (php:7.3) gate their entries as
    for Oracle. Findings link Red Hat's CVE page. A RHEL image scanned without the index is a
    coverage gap naming the command; a plain db sync leaves the derived exports to the scan
    instead of asking osv.dev for them. Validated against Trivy 0.73.0 on UBI 8.8 and UBI 9:
    every one of Trivy's 947 and 538 findings is reported with the same status; the 19 and 2
    more are Red Hat's open statuses for the binary's source package, which Trivy matches by
    binary name only.

  • Module streams on RHEL, AlmaLinux and Rocky Linux images (spec 16, row 10, phase 2).
    osv.dev's records for these distributions carry no module stream, so an advisory for
    php:8.0 matched an installed php:7.4 build as "fixed in 8.0.x". An advisory whose fix
    is a module build now takes its streams from its title (php:8.0 security update,
    virt:rhel and virt-devel:rhel ...) and matches only packages from those streams; a
    non-module fix no longer applies to a module build, and a fix built once per module
    context compares by its version and release. Another stream's advisory no longer hides
    Red Hat's open status for the installed stream. Also fixed: an rpm subpackage with an
    epoch of its own (perl-base 0:2.27) gave its source rpm that epoch, so perl's source
    looked older than 4:5.32.1 fixes. Checked against dnf updateinfo in Rocky Linux 8 and
    9 and AlmaLinux 8 images with module streams: 46 and 100 cross-stream false positives gone,
    AlmaLinux 8 equal to dnf; on a UBI 8 image with php, nodejs, ruby and perl streams, 171
    other-stream pairs gone, 27 open statuses for the installed streams back, and every one of
    Grype v0.121.1's 751 pairs reported.

  • CBL-Mariner 2.0 from Microsoft's OVAL (spec 16, row 10, phase 2). osv.dev's Mariner 2
    records stopped in April 2026, while Microsoft's OVAL ran on to May: 269 CVE and package pairs
    missing and 153 fixes still listed as open. The OVAL is now read over osv.dev's records
    (db sync --distros "Azure Linux:2::oval"); where it names a CVE for a package, including
    "Not Applicable", it wins. On a 2023 image every pair Grype v0.121.1 reports is reported with
    the same status, and every pair the raw OVAL finds affected.

  • CentOS Linux 6, 7 and 8 (spec 16, row 10, phase 2). Matched against Red Hat's records
    for the release each rebuilt, with Red Hat's open statuses. A Red Hat fix counts as fixed
    only when CentOS shipped it, from a bundled list of each release's final builds
    (crates/os/data/centos.tsv, vault.centos.org); otherwise it is fixed only in another line
    (all of RHEL 8's fixes since CentOS 8 ended). Rebranded builds (.el7.centos) compare as
    the Red Hat build they rebuilt. CentOS Stream remains a coverage gap. Equal to Grype v0.121.1
    on CentOS 7 (12,619 pairs, no status differs) and CentOS 8 (1,286 pairs; 557 Red Hat fixes
    CentOS 8 never shipped are fixed only in another line where Grype calls them fixed).

  • Fedora (spec 16, row 10, phase 2). Fedora 41 and later are matched against the updates
    repository's updateinfo.xml.zst (db sync --distros Fedora; from the Fedora archive once
    a release leaves the mirrors), its security updates only, with CVEs from the Bugzilla bugs
    each update closes. Findings link the Bodhi update. Equal to dnf updateinfo list --security on a Fedora 43 image (26 advisories, 51 advisory and package pairs). Fedora 40
    and older are a coverage gap.

  • End-of-life warnings for images (spec 16, row 10, phase 2). An image whose release is
    past the end of its standard support (CentOS 7, Debian 10, Amazon Linux 2, Fedora 41, ...)
    gets an unmaintained warning, EOL-<product>-<release>, grouped across the fleet, with
    the date and, where the vendor sells it, when paid extended support ends. The dates come
    from a snapshot of endoflife.date bundled in fleetreach-os (refreshed at release time
    by scripts/update-eol.py), so scans stay offline; the scan date honors
    SOURCE_DATE_EPOCH. On the 24 rpm test images it flags the six releases past their date;
    Grype v0.121.1 flags Amazon Linux 2 and Fedora 41 but not CentOS 7 or openSUSE Leap 15.5.

  • Red Hat's unfixed CVEs in AlmaLinux and Rocky Linux images (spec 16, row 10, phase 2).
    AlmaLinux and Rocky rebuild Red Hat Enterprise Linux from the same sources, so a CVE Red
    Hat has not fixed in RHEL 8 or 9 is not fixed in the rebuild either. Their scans take Red
    Hat's CSAF VEX open statuses and "not affected" for the matching RHEL release, where the
    rebuild's own records do not name the CVE for the package, titled no fix yet; Red Hat status .... Red Hat's fix versions are Red Hat's builds and are not borrowed. An AlmaLinux
    or Rocky image scanned without the Red Hat index is now a coverage gap naming the command.
    Against Grype v0.121.1 on six AlmaLinux and Rocky images, the 582 to 611 open statuses per
    image Grype reported and fleetreach did not are now all reported, with no status
    disagreements; the 4 to 18 more per image are Red Hat statuses newer than Grype's data.

  • SUSE's unfixed CVEs in openSUSE, SLES and SLE Micro images (spec 16, row 10, phase 2).
    db sync --source csaf:suse or db import --csaf csaf-vex.tar.bz2 --provider suse
    indexes SUSE's CSAF VEX (a 526 MB .tar.bz2, read in pure Rust), which scans of openSUSE
    Leap, Leap Micro and Tumbleweed, SUSE Linux Enterprise Server 15, SLE Micro and SUSE Linux
    Micro images consult as Red Hat's is consulted: open statuses become findings marked no fix yet, and fixes osv.dev lacks are reported with their version. SUSE names binary
    packages, each looked up by its own name and compared with its own version. A SUSE status
    outranks SUSE's recommended build, and a SUSE open status stands unless the release's
    records find the package affected (SUSE's update advisories also name CVEs they did not
    fix). Leap 15.x takes the fixes of the SLE 15 service pack it is built from, as fixed only in another line. Findings link SUSE's CVE page. A SUSE image scanned without the
    index is a coverage gap naming the command. Validated against OpenSCAP evaluating SUSE's
    OVAL: all 238 CVEs on SLES BCI 15.6.

  • SLES images are now matched against every SLE 15 module's osv.dev records (Containers,
    Python 3, Public Cloud and the rest) and against LTSS, which carries the service pack's
    later fixes.

  • db sync --distros Debian:12,Wolfi fetches distro exports one distribution at a time (the
    per-release export where osv.dev has one, else the whole distribution's), and a plain
    db sync fetches what the fleet's images need. db status lists the distro exports present.

  • Local advisory overlays (spec 16, row 12). [settings.advisories] dir points at a
    directory of OSV JSON records layered over every OSV feeder's export (npm, PyPI, RubyGems,
    Packagist, NuGet, Julia, Swift, Hex, GitHub Actions, Maven): a record with an upstream id
    replaces it, a new id adds an advisory, and withdrawn retracts one. Fail-closed: a
    missing directory, invalid JSON or a duplicate id stops the scan with exit 2. Records for Go
    or Rust are not applied and say so. The report's provenance.osv gains an overlay entry
    with a sha256 over the records.

  • CVE 5.x and Red Hat CSAF VEX indexes. db sync --source osv,cve,csaf:redhat (network
    build) and db import --cve <dir|zip> / db import --csaf <dir|tar.zst> --provider redhat
    reduce cvelistV5 (CNA affected data, ADP enrichment) and Red Hat's CSAF VEX archive (every
    product status plus will-not-fix, fix-deferred, out-of-support and similar remediations) to
    compact indexes next to the OSV exports, with sha256 and dates in db status. Scans of
    RHEL images match against the Red Hat index (above).

  • db quality: data-quality checks on the advisory data as the matchers see it
    (unmatchable entries, versions outside ranges, events out of order, unparseable bounds,
    alias conflicts, live records aliasing rejected CVEs, missing severity, withdrawn records,
    overlay records not applied, stale or reviving). Exit 1 on an error-level issue.

  • db crosscheck: JSON counts, with examples, of what the CVE and CSAF indexes add to or
    contradict in the OSV data.

  • Additive APIs: load_with_overlay and iter on every OSV feeder database, and
    osv::load_with_overlay / osv::read_overlay in fleetreach_core. OsvSettings gains an
    advisories field.

Fixed

  • A hostile repo can no longer hang a scan or read outside itself. A manifest or lockfile that
    was a symlink to /dev/zero, or to a file beyond the repos in the fleet, was followed. Manifests,
    lockfiles and source files now go through one reader: it refuses what is not a regular
    file, anything that resolves outside the repo, and files over 512 MiB.

  • licenses --detect could hang. Building the license matcher could deadlock on a busy thread
    pool, about one run in three.

  • A file in the default triage/ directory that names no advisory is skipped with a warning
    instead of failing the scan. A directory you name with --triage-dir stays strict.

  • fix plan on a report with images listed lock bumps nothing could apply. An edit with no
    checkout in fleet.toml is now blocked, and says the image takes the fix at its next build.

  • Go findings have severities. They all read unknown and so failed every --fail-on
    floor. The offline matcher now reads GitHub's records in the osv.dev export, and a GO- record
    takes the worst band of the records sharing an id with it. A Go finding under the floor no
    longer fails it. What nothing rates stays unknown and still fails, as do all findings from
    govulncheck or a vuln.go.dev mirror, which carry no severity.

  • A repo scanned from sbom = with no lockfile of the same ecosystem errored, because the
    advisory data for what the SBOM held was never loaded.

  • Dependency paths for RubyGems now go through gems from GIT and PATH sources.

  • A pnpm file: or tarball dependency no longer appears as a package with a path for a version.

  • fix apply could destroy a verified branch. A re-run that failed its baseline scan
    deleted the branch. Branches now move only after a commit, and an unverified result goes
    on fleetreach-unverified/*, never over a verified branch.

  • Human VEX statements ([[settings.ignore]], [[settings.vex_assertion]]) named every package
    as pkg:cargo, so a statement on an npm or PyPI package matched nothing in other tools.

  • Rust scans missed the advisories only GitHub carries. RustSec has no record of about 650
    live crates.io advisories (rustix, deno, surrealdb among them), so Cargo.lock files
    and Rust binaries read clean of them. The osv.dev crates.io export is now synced and matched
    beside RustSec, and --crates-vuln-db points at a copy. A package RustSec already reported
    an advisory for keeps RustSec's finding, so nothing is reported twice; where GitHub's range
    or crate list is wider than RustSec's the package is reported, and what RustSec withdrew
    stays withdrawn. Checked on 600 real lockfiles: every row added is one Trivy and Grype both
    report, and an independent evaluation of the records agrees row for row.

  • Debian, Ubuntu and Alpine advisories were two years old. Sync preferred osv.dev's
    per-release exports (Debian:12/all.zip), which still download but stopped changing in
    October 2024, so every later CVE was missed. Sync now fetches the whole distribution's
    export, and a scan warns when an export has not changed for a year. Found by the Trivy and
    Grype differential.

  • Debian 7 to 11 lost the CVEs they left open when they left the security tracker. Their
    frozen osv.dev exports are now read too, wherever the maintained export says nothing about a
    CVE; db sync --distros Debian:11 fetches both, --max-db-age does not apply to a frozen
    export, and the image's coverage gap says the data stops in October 2024.

  • Root's patched images could read as clean when they were not. Root numbers its builds
    on one counter under two spellings, .root.io.N and .aikido.N, and dpkg sorts aikido
    below root, so a package at root.io.2 counted as past a fix at root.io.3. Versions now
    compare by the counter. Packages Root renames (rootio-coreutils) now get Debian's and
    Alpine's records, records filed under either name are found, Root's apk builds
    (-r00072) are recognized, and Root's fix is shown for packages it has not rebuilt. Found
    on Root's public images: every Root row Trivy reports is now reported too.

  • A registry that rate limits a pull (429) is now waited for and tried again.

  • Files of third-party OS packages in images (docker-ce-cli, mongodb-database-tools) were
    skipped as if a distribution's advisories covered them. They are skipped now only when a
    distribution's records know the package, on dpkg, rpm and apk images.

  • Ubuntu Pro's records were read only for +esm images; on any LTS they now speak about CVEs
    the release's own records never mention.

  • CentOS 6 images have no os-release and were not matched; they are now read from
    /etc/centos-release, and RHEL's from /etc/redhat-release. CentOS stays affected by a Red
    Hat fix made after it stopped.

  • Red Hat's Extended Life Support records are read for RHEL 6 and 7, and RHEL 10's records,
    which go by minor release, are read at all. A Red Hat record naming only the source package
    now applies to binaries it does not list.

  • A Ubuntu or Debian notice no longer joins the CVEs it covers into one finding that takes the
    first one's status. A finding's title no longer names another release's status, and one
    GitHub record naming packages in two ecosystems stays two findings.

  • Alpine ranges whose lower bound is above their fix hid open CVEs; the bound is dropped.

  • Go records from GitHub in osv.dev's Go export were dropped, and +incompatible versions missed
    last_affected bounds.

  • A package.json marked "private": true is not matched as a registry package.

  • A retired Debian release now reports a coverage gap, where its CVEs went silently unreported.

Compatibility

  • fleetreach_report::HumanAssertion gains an ecosystem field, fleetreach_cli::Suppression
    gains scope and accepted_risk, and fleetreach_cli::config::Config gains triage.

  • fleetreach_scan::scan_lockfile takes the new Option<&CratesDb> as its second argument;
    None keeps the RustSec-only behavior.

  • A Rust repo or image scanned without the crates.io export now gets a partial coverage gap,
    as a repo with workflows does without the GitHub Actions export. RustSec's findings are
    unchanged. Network builds fetch the export on their own; offline ones need it from
    fleetreach db sync or --osv-dir.

  • fleetreach_core::Ecosystem gains the Deb and Apk variants (JSON deb, apk). The
    enum is not #[non_exhaustive], so an exhaustive match on it in code that depends on
    fleetreach-core needs a new arm. No existing variant or JSON value changes.

  • fleetreach_cli::config::Config gains a public images field (as 1.5.0 added sboms and
    context); code building a Config literal adds images: Vec::new().