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
50% of the analysed CVEs don’t affect this device
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.
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.


Three CVEs, three different verdicts
CVE-2021-3864: A core pattern decides trigger possibility (and the fix)
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
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
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.