Article

Fixes Are Getting Faster. Can You Find Where They Go?

Oct 26, 2026

Open source security is getting harder at both ends. Finding vulnerabilities, and proving which ones actually affect the code you ship, is more difficult than ever, and AI is adding both volume and uncertainty. Fixing them has become just as hard. On October 6, IBM and Red Hat showed one serious answer to the fixing side. Their Lightwell initiative has found, fixed and backported more than 400 previously unknown vulnerabilities in widely used Java libraries. Its Clearinghouse, now generally available, lets enterprises submit the open source dependencies they care about for priority review and version-specific fixes.

Lightwell launched in May with a $5 billion commitment and more than 20,000 engineers. It arrives as volumes climb: Google’s threat intelligence team counted monthly vulnerability disclosures doubling between January and August 2026, and Microsoft expects around 72,000 CVEs this year. AI is speeding up discovery, but every new finding still has to be traced to the code that actually ships, and AI-generated code makes that tracing harder. Fixes, especially for older versions still in production, remain slow and expensive.

Lightwell’s first results are in Java, and many product makers will never use it directly. The lesson still applies to them. An automotive supplier, a medical device maker or a consumer electronics brand maintains vendor kernels, bootloaders and dozens of libraries across product lifecycles of ten years or more. They face the same questions, whoever supplies the fix.

A service that turns ‘we know it’s vulnerable’ into ‘here is a tested patch for the version you run’ removes one bottleneck. It does not remove the other. To ask for a fix, you first have to find, and prove, exactly what you have.

What a fix request assumes

IBM describes the Clearinghouse as a way for customers to “submit specific open source software dependencies for priority review and remediation,” with fixes delivered for “older software versions still in use.” It is designed to sit beside existing tools, “without replacing their current security scanners.”

That model is sensible, and it quietly puts three questions on the customer’s side of the table:

  1. Which component? You can only submit what you know is in your code.
  2. Which exact version? A backport is built for a specific release, not for a family of releases.
  3. Where does it ship? A fix only reduces risk once it reaches every product and release that contains the component.

Lightwell supplies the fix. The customer still has to supply the map. That holds wherever fixes come from: a chip vendor’s board support package update, a commercial Linux provider, an upstream stable branch or your own engineers. For many organizations, the map is less complete than they think.

Where the map has gaps

Most software inventories are built from package manifests: the files that tell npm, Maven or pip what to install. Manifests are useful, but they only record what someone declared. Black Duck’s 2026 OSSRA report found that 17% of open source components in the codebases it audited entered without going through a package manager at all.

That undeclared code tends to arrive in a few familiar ways:

  • Vendor BSPs and SDKs. Chip vendors ship kernels, bootloaders and SDKs as source trees built on an upstream release with large sets of their own patches. They arrive as a tarball or a Git tree, not a package, and the version string still names the upstream release.
  • Vendored code. Teams copy a library’s source into their own repository, often into a vendor/ or third_party/ folder, to freeze a version or patch it locally. From then on it is just files in the tree, and no manifest lists it.
  • Copied files and fragments. A developer pastes in a function, a parser or a single file from an open source project. It works, it ships, and nobody records where it came from.
  • AI-generated code. Coding assistants produce snippets that can closely match open source originals, with no dependency declared and no attribution attached.
  • Languages without a package manager. In much C and C++ code, reuse means copying source in, so manifests may describe little of what is really there.

manifest vs code scan

None of this code will ever be submitted to a clearinghouse, because nobody knows it is there. Finding it means looking at the code itself, which is where FossID works. Signature scanning identifies open source files and components from their content rather than their declarations. Snippet detection goes further and matches fragments, so a copied function inside a proprietary file is still recognized, even after formatting changes or renaming.

Close enough is not enough

Version numbers are a weak guide even before backports come into it. A BSP kernel that reports itself as 5.10 may carry thousands of vendor patches, some of which fix CVEs and some of which add new code. Build-system CVE checks generally reason from declared versions and recorded patch lists, so they inherit whatever those records get wrong. A backport needs more precision still: it is built and tested against a specific version, and it may not apply cleanly to anything else.

Local modification makes this harder. Vendored copies are often vendored precisely so teams can change them. After a few years of local edits, a copy may match no released version at all. Its declared version, if it still has one, says little about which code is actually inside.

That leaves two failure modes. Teams request the wrong fix for a copy they misidentified. Or they never request a fix, because the copy no longer looks like the library a scanner expects to see.

Look for the vulnerable code, not the version number

Backports create one more blind spot. A patched build often keeps its original version number, because the point of a backport is to fix a release without upgrading it. A patched copy and a vulnerable copy can therefore carry the same version string. Any tool that decides exposure from version numbers alone cannot tell them apart.

The more reliable question is whether the vulnerable code itself is present. A CVE usually comes down to a specific set of lines. Matching those lines directly, rather than the package name and version around them, answers the question in both directions:

  • Before the fix, it finds unpatched vulnerable code even in a vendored copy that has been modified beyond recognition, so the right components get submitted.
  • After the fix, it confirms the vulnerable lines are gone from each shipped release, even though the version number never changed.

same version different code

This is the approach behind FossID’s Vulnerable Snippet Finder, which looks for the lines tied to known CVEs whether the code arrived as a package, a vendor tree, a copied fragment or AI output.

Finding vulnerable code in the source is the start of the assessment, not the end. In embedded products much of the source tree never reaches the firmware: kernel drivers are compiled out, features are disabled in the build configuration, and some code paths cannot be reached on the target hardware. Line-level matches tell your team exactly where to look. Build configuration and engineering judgment then decide whether the product is affected, and that decision belongs in a VEX statement that customers and authorities can read.

This matters well beyond Lightwell, because every major product regulation now expects manufacturers to know what they ship and act on vulnerabilities in it:

  • Consumer and industrial electronics fall under the EU Cyber Resilience Act. Manufacturers must report actively exploited vulnerabilities within 24 hours and provide security updates for a support period that defaults to at least five years.
  • Vehicles are covered instead by UN R155 and R156, which require a cybersecurity management system and managed software updates across the vehicle’s life, with ISO/SAE 21434 as the working standard. Suppliers inherit those duties through their contracts.
  • Medical devices are covered by their own rules. In the US, Section 524B of the FD&C Act requires an SBOM and a plan to monitor and fix postmarket vulnerabilities. In the EU, cybersecurity sits within the Medical Device Regulation.

None of these is satisfied by a list of declared dependencies. Each one asks, in some form, ‘which of our shipped products contain this flaw, and which now carry the fix?’

Where to start

No team can inventory everything at once. This order gets the most value from the first few months, whoever supplies your fixes:

  1. Start with what is on the market and in support. Prioritize products inside their support period and network-facing components such as the kernel, bootloader, TLS library and shell utilities.
  2. Scan the source you ship, not just the manifests. Include BSPs, vendored trees, copied code and AI-generated code. Tie each scan to a firmware release tag and keep it.
  3. Record exact versions and local drift. Note where a copy has moved away from its upstream release, and which vendor patches it carries.
  4. Hold suppliers to the same standard. Ask for source or a detailed SBOM with each delivery, scan source deliveries on receipt, and agree how suppliers will notify you of vulnerabilities. In a tiered supply chain, that requirement has to flow down every tier.
  5. Check for the vulnerable code, then decide exposure. Use line-level matches to find it and build configuration to judge whether it is reachable. Record the outcome as VEX.
  6. Re-scan after every fix. Confirm the vulnerable code is gone from each release and update the SBOM to match.
  7. Rehearse the 24-hour question. Take a recent CVE and time how long it takes to answer ‘which shipped firmware contains this?’ That number shows how ready you are for regulatory reporting and customer inquiries.
  8. Name an owner for fix requests. Someone has to decide what goes to a chip vendor, a commercial provider or your own engineers, and when.

Finders, fixers and the map

The open source security market is filling in quickly on two sides. AI models from Anthropic, Google and others are surfacing vulnerabilities faster than maintainers can absorb, while AI-written code makes it harder to know where open source has ended up. Services such as Lightwell are scaling up the work of fixing them, including for old versions that upstream projects no longer support.

Between the two sits a layer every organization must own: a proven, accurate record of what is actually in its software. That is the problem FossID was built for, and the one this article argues gets harder, not easier, as AI accelerates both sides. Fixes will keep getting faster and cheaper. The organizations that benefit most will be the ones that can say, with confidence, exactly where each fix needs to go.

Sources

Aaron Branson, Chief Growth Officer

Aaron Branson, Chief Growth Officer

As Chief Growth Officer of FossID, Aaron focuses not only on communicating the value of FossID technology and professional services, but also on understanding trends and challenges our clients face with the goal of publishing insights to help overcome them. Aaron has over 25 years of experience in software design, development, and project management.

Table of Content

    Sushi Bytes Podcast

    Talk to a Software Supply Chain Ninja

    Book a discovery call with one of our experts to discuss your business needs and how our tools and services can help.