What a running device knows that its SBOM doesn't

What a running device knows that its SBOM doesn't

What a running device knows that its SBOM doesn't

Yocto flagged 703 kernel CVEs as Unpatched. Corefense analysed 100 of them against the running device to determine which ones actually matter.

Yocto flagged 703 kernel CVEs as Unpatched. Corefense analysed 100 of them against the running device to determine which ones actually matter.

7 min read

An “Unpatched” CVE in a Yocto report doesn’t mean the vulnerability is reachable on the device. The bug might be compiled in, but the conditions to trigger it may not exist.

To measure that gap with Corefense, we built and booted Wrynose’s latest core-image-minimal image (Linux 6.18.52) in QEMU, and assessed 100 of the 703 kernel CVEs that remained “Unpatched” after Yocto’s compiled-source filtering.

This blog walks through the analysis and approach, with three CVE examples.

Analysis Scope

We built Yocto Wrynose’s core-image-minimal with Linux 6.18.52, and used its build-time CVE report (generated by sbom-cve-check) as the starting point for analysis.

Note: This blog covers Linux kernel CVEs only. User-space packages are outside the scope.

Its compiled-source filter marked 977 Ignored and left 703 Unpatched.

Of the 703, we selected 100 CVEs spanning networking, drivers, filesystems, BPF and memory management. 38 of them have no CVSS score yet, as is common for newer kernel CVEs, while the rest require low or no privileges with local attack vectors.

Results for the 100 analysed CVEs

100CVEs analysed
Affected4 (4%)Reachability conditions satisfied
Not affected49 (49%)Vulnerable code absent or reachability conditions not met
Already fixed (CVE-2022-1247)1 (1%)Its CVE record names no fix; Corefense research traced it
Needs review46 (46%)Observed evidence insufficient, needs human decision

50% of the analysed CVEs don’t affect this device

Required build conditions not met
Affected source file is compiled, but an additional build condition needed to trigger the fault is absent.
17
Module built but not shipped
Affected module was built, but was not included in the device image.
17
Fault-containing source not compiled
Source containing the fault was not compiled. Other files listed in the CVE record caused the filter to retain the finding.
6
Required runtime resource absent
Researched route needs a resource that was absent at scan time, such as a mounted SMB share.
6
Required runtime condition not met
A specific runtime requirement was missing: CPU tracing with address filters, or a share mounted with SMB1.
2
Outside the fault-triggering version range
CVE record's range includes 6.18, but Corefense research found the fault can only be triggered from 6.19.
1
Fix already in the kernel
CVE record names no fix, but Corefense research traced one already in this kernel (CVE-2022-1247).
1

From CVE to evidence-backed verdict

Organising the research

For each published CVE, we guided multiple AI agents as security researchers to study the vulnerable code through kernel source, patch commits and CVE records, and translate it into the conditions needed to trigger it. The agents additionally used code property graph (CPG) queries to internally verify those conditions.

The research was then normalised into an internal representation that guides the on-device scanner, and subsequent reachability evaluation.

AI-assisted research
Trace each published CVE through kernel source, patch commits and CVE records.
Multi-agent review
Every finding is challenged by another reviewer agent on a separate model.
CPG-guided tracing
Graph queries over the compiled kernel (IR) confirm which paths reach the flaw.
Source-backed trigger analysis
Normalisation
Turn research findings into conditions a device can be checked and evaluated against.
Structured exploit conditions

Evaluation

A read-only scanner collects facts relevant to the CVEs being assessed. No firmware, keys or secrets are uploaded, and the collected facts can be verified before they’re sent for evaluation.

An evaluator then checks those facts against the normalised research, and returns a verdict with evidence. Where evidence is insufficient, the verdict remains “Needs Review”.

We’re offering two deployment choices for our users: local (on-device) evaluation, or through a centrally managed platform for deeper visibility and advanced analysis.

No firmware or image secrets leave the device in either case.

Evaluation on the device
ON THE DEVICECorefense scanner+ evaluation engineread-onlyTerminal output + VEX
ON THE DEVICE
Corefense scanner + evaluation engineread-only
↓
Corefense terminal UI explaining CVE-2026-93817 as not affected
Terminal output + VEX
Evaluation on Corefense cloud
ON THE DEVICECOREFENSE SECURE CLOUDCorefensescannerread-onlyEvaluationengineFacts only,over HTTPSCorefense dashboard
ON THE DEVICE
Corefense scannerread-only
↓
Facts only, over HTTPS
COREFENSE SECURE CLOUD
Evaluation engine
↓
Corefense dashboard scan summary
Corefense dashboard

Three CVEs, three different verdicts

CVE-2021-3864: A core pattern decides trigger possibility (and the fix)

NEEDS REVIEWSystem precondition met but the execution path has not been verified.

Research

This CVE concerns core dumps from setuid programs. A setuid-root program that sets its real IDs to root and then starts another program leaves that program dumpable. If it crashes and kernel.core_pattern is relative, the kernel writes a root-owned core file into its current directory, which the attacker chooses. No upstream fix exists; the decision is unchanged in the exec code of 6.18.52:

if (bprm->interp_flags & BINPRM_FLAGS_ENFORCE_NONDUMP ||
    !(uid_eq(current_euid(), current_uid()) &&
      gid_eq(current_egid(), current_gid())))
    set_dumpable(current->mm, suid_dumpable);
else
    set_dumpable(current->mm, SUID_DUMP_USER);

Corefense’s AI agents researched this code and translated it into the runtime condition needed to trigger it: kernel.core_pattern must be a relative path, such as the default core or ../. An absolute path or a pipe sends the dump elsewhere. The research also ruled out fs.suid_dumpable as a mitigation: the SUID_DUMP_USER branch never reads that setting.

Device observations

The scanner read kernel.core_pattern=core, so the precondition holds. Corefense confirmed the system prerequisite, but the binary call path is not analysed at this stage, so the verdict stays “Needs Review”.

We manually changed the running device’s core pattern to an absolute path, and a rescan flipped the verdict to “Not Affected”.

This image ships neither /etc/sysctl.conf nor a sysctl.d directory. Corefense read the effective setting directly from the running device and used it to determine the verdict.

CVE-2026-98021: Two potential routes on this device

AFFECTEDPotentially reachable via unprivileged user namespace, or 8 processes already holding CAP_NET_ADMIN.

Research

This CVE is an unchecked transmit queue length supplied through netlink, which can cause excessive queue allocations and potentially deny service. The value passes from the network attribute policy and its assignment to the link to the queue allocation code:

[IFLA_TXQLEN]        = { .type = NLA_U32 },

if (tb[IFLA_TXQLEN])
    dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);

Corefense’s AI agents translated this code into the condition needed to trigger it: a caller needs CAP_NET_ADMIN in the socket’s network namespace. Host-level administrator privileges are not necessarily required, as the kernel’s permission check shows:

if (kind != RTNL_KIND_GET && !netlink_net_capable(skb, CAP_NET_ADMIN))
    return -EPERM;

Device observations

The scanner observed no unprivileged processes, but user and network namespaces were enabled (CONFIG_USER_NS=y, CONFIG_NET_NS=y), with user.max_user_namespaces=7892.

Additionally, eight processes, including sshd, held CAP_NET_ADMIN without a seccomp filter.

Corefense evaluated the observed facts against its structured research, and found two potential routes: via unprivileged user namespace, or execution within a privileged process. These routes assume attacker-controlled execution in the identified privilege context.

CVE-2026-93817: No address-filter PMU on this board

NOT AFFECTEDNone of the 7 perf event sources on this device supports address filters.

Research

Perf address filters limit hardware tracing to chosen code ranges, such as one function in a program. This CVE is a use-after-free in that code: closing a perf event frees the filter array while an executable mmap() can still write to it:

/* close(): __free_event() */
kfree(event->addr_filter_ranges);

/* mmap(): __perf_addr_filters_adjust(), under RCU */
if (perf_addr_filter_vma_adjust(filter, vma,
                                &event->addr_filter_ranges[count]))
    restart++;

Corefense’s AI agents researched this code and translated it into the condition needed to trigger it: a perf event source (PMU) that supports address filters, in practice Intel PT or CoreSight ETM. The research found that the kernel exposes /sys/bus/event_source/devices/<pmu>/nr_addr_filters only for such a PMU, so the trigger needs that sysfs path to exist, and that is what the scanner checks:

/* pmu_dev_is_visible(): attribute 2 is nr_addr_filters */
if (n == 2 && !pmu->nr_addr_filters)
    return 0;

Device observations

The build and version both point to affected: CONFIG_PERF_EVENTS=y, CONFIG_CPU_SUP_INTEL=y, and 6.18.52 is below the 6.18.53 fix. The scanner then checked the path the research established, /sys/bus/event_source/devices/*/nr_addr_filters. This QEMU board has seven event sources, and none has that file.

Evaluated against the researched conditions, the required PMU was absent. This supports the “Not Affected” verdict for this board despite the code being compiled in.

The image alone can’t answer this. The Intel PT driver is built into this kernel but only registers on a CPU with the feature, so the same image on hardware with Intel PT address filtering would create that path, and this verdict would no longer hold.

What you get

Our goal is to make CVE triage faster and better, helping teams prioritise vulnerabilities that genuinely affect their products.

For every analysis, Corefense gives an evidence-backed verdict and potential remediations, both at the patch and device-configuration level. Where reachability is inconclusive, it flags a candidate for further investigation with supporting evidence to help teams make informed decisions.

Corefense is in early development, and we’re running a limited number of pilots to evaluate it on real-world deployments using Yocto, OpenWrt, and Buildroot.

Want to test Corefense on your image?

Want to test Corefense on your image?

Want to test Corefense on your image?

Bring your image and SBOM, and we will assess the CVEs together.

Bring your image and SBOM, and we will assess the CVEs together.

Corefense Security UG © 2026