Java4Shell and Trivy Operator in Radar: Which Running Containers to Patch First
Radar v1.21 checks running containers for Java4Shell without a scanner, puts Pods on the CPUs the bug actually affects (Intel Ice Lake and AMD Zen 4 or newer) first, and rolls Trivy Operator's reports up to the images that run now.

Java4Shell (CVE-2026-114938) went public on November 17. It's a memory-corruption bug in HotSpot's x86-64 Base64 intrinsic, in OpenJDK 17.0.6 and newer and the builds made from it, and only CPUs with AVX-512 VBMI (Intel Xeon from Ice Lake, AMD from Zen 4) reach the vulnerable code. In a Kubernetes cluster that turns triage into two questions: which running containers run an affected Java, and which of them sit on nodes with that CPU feature?
Radar v1.21.0, released November 19, answers both with Check for Java4Shell, an on-demand check that needs no scanner in the cluster. The same release adds Checks → Vulnerabilities, which rolls Trivy Operator's reports up to the images that run now, for every other CVE. This post covers both.
Compared to other vulnerability tools, Radar's angle is the running cluster. A scanner tells you which images carry a CVE. During a CVE response the questions are narrower: which workloads run those images right now, on which nodes, and what is the smallest upgrade that clears them. Radar answers from the cluster's live state. It counts only the containers that run now, matched by the digest the kubelet reports, reads node CPU labels and Pod spec flags that aren't in the image, and lists what it couldn't check instead of counting it as clean. It doesn't replace your scanner: the Vulnerabilities tab reads what Trivy Operator already wrote, and the Java4Shell check doesn't need one.
All of it is in Radar OSS, the free Apache-2.0 binary that runs on your laptop against your kubeconfig.
Java4Shell, briefly
From Calif's write-up:
- The bug. For a short input with a trailing
=, the hand-written assembly that decodes the last few characters builds the wrong write mask, and the decoder writes past the end of its output buffer before Java rejects the input. Any application that decodes Base64 an attacker can influence, in an auth flow, a file upload or a network message, can be exposed. The write-up says turning the overwrite into code execution takes application-specific work and that there is no universal exploit. - The CPU condition. The vulnerable path uses AVX-512 VBMI instructions, found on Intel Xeon from Ice Lake and AMD from Zen 4. ARM64 isn't affected. The JIT has to compile the intrinsic first, so the code path is reached once the decoder is warm.
- Mitigations until you can upgrade.
-XX:-UseBASE64Intrinsicsturns the intrinsic off, and-XX:UseAVX=2turns off AVX-512. Use the second only on x86-64: OpenJDK on ARM doesn't recognize it and won't start.
The fix is an upgrade. Radar treats these as the first fixed releases: 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. Versions 18 to 20, 22 to 24 and 26 count as affected with no fix listed. Java 8 (apart from Oracle's 8u511b33-perf build), 9 to 16, and 17 before 17.0.6 count as not affected.
Check your cluster for Java4Shell
Open Checks → Vulnerabilities and click Check for Java4Shell. This is the same test cluster, checked across all namespaces:
adservice is the Java service in Google's Online Boutique demo; the other two are Deployments we run to test the check. Every row says the CPU capability is unknown because this cluster doesn't run Node Feature Discovery, so nothing tells Radar which nodes have AVX-512 VBMI.
The check runs with or without Trivy Operator. For each running container, Radar reads the image config for the digest the Pod runs and compares the JAVA_VERSION it declares with the advisory's affected ranges. Matches are grouped by workload, container and build, with the declared version and the fix when one is known.
What decides the order:
- CPU. Groups with Pods on x86-64 nodes that Node Feature Discovery labels
feature.node.kubernetes.io/cpu-cpuid.AVX512VBMI=truecome first, and each group says how many of its Pods are on such nodes and how many are unknown. Without those labels or read access to Nodes, the CPU capability reads as unknown, not as safe. - Declared mitigations. When a container passes
-XX:-UseBASE64Intrinsicsor a-XX:UseAVXvalue of 2 or lower, in its command, its args,JAVA_TOOL_OPTIONS,JDK_JAVA_OPTIONSor_JAVA_OPTIONS, the group counts it as declared. It doesn't lower the priority.
Containers Radar couldn't assess are listed under Unassessed containers with the reason and their Pod count, so a missing declaration doesn't read as safe. An image that sets JAVA_HOME but declares no version, such as the official Amazon Corretto 21 image, is listed first with a prompt to check the installed Java version. Download JSON saves the result with the check time and which namespaces it covered.
Registry reads try anonymous access first. For private images Radar uses the Pod's pull secrets, and when Radar runs with sign-in, only for callers allowed to read that pull secret or to exec into the Pod. Images Radar can't read stay unassessed.
Where Trivy Operator runs, Find in Trivy reports searches what its reports recorded for the same CVE. A report written before November 17 can't list it, so images scanned before then show nothing until Trivy rescans them. The Java4Shell check reads the image config itself, so it doesn't wait for a rescan.
The same check runs per workload from the Deployment, StatefulSet and DaemonSet drawer, and from the terminal:
radar check java4shell -A -o json --fail-on-matchIt uses your kubeconfig and the current context's namespace unless you pass -n or -A, and -A needs cluster-wide permission to list Pods. It exits with 0 after a completed check and 1 if the check can't run. With --fail-on-match it exits with 2 when any container declares an affected version, so it fits in CI. Check the unassessed counts too: a container Radar couldn't assess doesn't fail the build.
A declared version is what the image says, not proof of the JVM inside it, and Radar compares upstream version numbers, so a vendor build with its own revision needs that vendor's advisory. Treat a match as a reason to confirm the installed JVM and its vendor's fix.
Every other CVE: the Vulnerabilities tab
Trivy Operator scans the workloads in your cluster and writes the results back into the cluster as custom resources: a VulnerabilityReport per container, plus config audit, exposed secret, RBAC, infrastructure, compliance and SBOM reports. That puts the findings next to the workloads, readable through the Kubernetes API. It also means reading them is kubectl get vulnerabilityreports -A -o yaml and a lot of jq, one report per container per ReplicaSet, with every finding nested under a top-level report field.
Radar reads those reports, and the Vulnerabilities tab counts only the images that run now, matched by the digest the kubelet reports for each container, with the lowest release that clears each package's fixable CVEs. This is a test cluster running Trivy Operator:
62 of the 99 scanned images carry Critical CVEs. Another 16 running images have no report yet, so the totals read as lower bounds (≥) instead of pretending those images are clean. Each row is one image, however many workloads run it, with its findings by severity, how many of them have a fix, and the workloads and namespaces that run it.
Radar has rendered the individual reports since February, and since v1.18 it searches their findings by CVE, package or image.
What you need installed for Trivy
Trivy Operator does the scanning. Radar doesn't run a scanner; it reads what the operator wrote. If you don't run the operator yet, its Helm chart is the usual install:
helm repo add aqua https://aquasecurity.github.io/helm-charts/
helm repo update
helm install trivy-operator aqua/trivy-operator \
--namespace trivy-system --create-namespaceThen run Radar:
brew install skyhook-io/tap/radar
radarThe report kinds appear under Resources once the aquasecurity.github.io CRDs exist. Radar installs nothing in the cluster. If you run Radar in-cluster from its Helm chart instead, the chart grants read on the Trivy group by default (rbac.crdGroups.trivy: true).
The Vulnerabilities tab needs v1.21.0 or newer; search and the report views below work from v1.18.1.
How the Vulnerabilities tab decides what counts
Trivy Operator writes one VulnerabilityReport per container per scanned object, and a cluster can still hold reports about workloads that no longer run. The tab counts only what runs: Pods that aren't finished and CronJobs that aren't suspended. It matches each report to the image by the digest the kubelet reports for the running container, so a tag pushed again, such as :latest, doesn't inherit an older build's scan. Reports about older revisions and removed workloads are left out and counted.
It has four views, and the severity and Has a fix filters apply to all of them:
- By image (above): one row per running image.
- By CVE: each CVE with the images and workloads that carry it, and how many of those images have a fixed release.
- By workload: each workload's containers and what their images carry.
- By fix: the fixable findings as package upgrades, each with the version to move to and every CVE it clears. Radar picks the lowest listed release that fixes all of them, using the package's own versioning (Debian, Alpine, RPM, PEP 440, semver and others). Trivy lists one fix per maintained branch, so a package at
6.11.4with fixes in8.0.1, 7.5.5, 6.11.6gets6.11.6, not a major-version jump.
The same rollup shows up as a Vulnerabilities line on Home's Cluster Checks card and as a section in the Deployment, StatefulSet and DaemonSet drawer, next to that workload's Java4Shell check. The rollup, the Home line and the drawer's report section need the cluster to serve Trivy's VulnerabilityReport kind.
Radar counts a CVE once per package version in an image, so its totals can be lower than the summaries in Trivy Operator's own reports.
What each Trivy report looks like in Radar
Open any report for the full detail. This is a VulnerabilityReport for a Debian-based PHP service, filtered to two CVEs:
The header says what was scanned and when: container, image, OS, the Trivy version and the scan age. The severity bar counts findings by level. The table below it sorts by CVE, severity, score, package, installed version or fixed version, filters by CVE or package name, and Fixable hides findings with no fixed version yet. Clicking a severity in the summary filters to that level.
Radar has a dedicated detail view for ten Trivy Operator report kinds, all in aquasecurity.github.io/v1alpha1, and table columns for the main ones:
| Report | What it holds | What Radar shows |
|---|---|---|
| VulnerabilityReport | CVEs in one container's image | Container, image and C/H/M/L counts in the table; the view above in detail |
| ConfigAuditReport | Misconfiguration checks on a workload's spec | Pass/fail checks with severity, description and remediation, or "All checks passed" |
| ExposedSecretReport | Secrets Trivy found baked into an image | Rule, category, severity, target and the match |
| RbacAssessmentReport, ClusterRbacAssessmentReport | Checks against Roles and ClusterRoles | The same check view as config audit |
| InfraAssessmentReport, ClusterInfraAssessmentReport | Checks against node and control-plane components | The same check view as config audit |
| SbomReport, ClusterSbomReport | The image's software bill of materials | Components with name, version, type and license, filterable by name, type or purl |
| ClusterComplianceReport | A compliance framework's controls, rolled up | Framework, version and controls, filterable by control name or ID |
Reports are kept out of the topology graph on purpose. A cluster has one VulnerabilityReport per container per ReplicaSet, and drawing each one as a node would bury the workloads they describe.
Search Trivy findings by CVE, package or image
Press ⌘K and type the CVE:
The result is the report, not the Deployment, and the in findings label says it matched inside the report rather than on its name. Search covers:
- CVE IDs, with the package and the installed and fixed versions
- SBOM component names and versions
- failed check IDs, such as
KSV012 - secret rule IDs and targets (never the matched line)
- the scanned image, so
image:php kind:VulnerabilityReportlists every report for a PHP image
Severity words and finding titles aren't indexed, so critical won't find critical CVEs. The C column in the VulnerabilityReport table is the place for that.
The Resources table for a report kind has the same search in its search box. A row that matched only through a finding is tagged in findings, with the finding on hover. Regex mode matches names and namespaces only, and one table search stops after 200,000 findings and says some weren't searched.
To match a single finding instead of any finding in the report, the search filter takes CEL with a report binding:
report.vulnerabilities.exists(v, v.vulnerabilityID == "CVE-2026-109618" && v.resource.contains("php"))Without it, a query with two terms can match one term in one finding and the other term in another.
We built this search for PHP2Shell. Finding PHP2Shell in Kubernetes walks through a full CVE hunt with it, including the PHP that Trivy doesn't report.
Your AI agent reads the same reports
Radar's MCP server gives agents the Vulnerabilities rollup as list_vulnerabilities, with the same four views plus view=summary for totals alone. It's listed only when the cluster serves the VulnerabilityReport kind, and it reads reports only where the caller may list them, naming the namespaces it couldn't read instead of returning an empty answer.
The same server exposes the search to Claude, Cursor or any MCP client. The search tool matches the same fields as ⌘K, and the REST and MCP results carry more than the UI row does: the matched finding, the package with installed and fixed versions, and the workload behind the scanned ReplicaSet with its desired replica count. If Radar can't find the scanned object, the result marks it missing instead of attributing the finding to whatever runs now.
In list_resources, the summary of each report (every kind except ClusterComplianceReport, which keeps its results elsewhere) gives the agent the scanned image, the object it belongs to when Trivy's labels name it, the finding counts and how long ago the scan ran, so it can tell a fresh report from a stale one.
Two things agents don't get. An ExposedSecretReport's match field quotes the line where Trivy found a secret. Trivy replaces the secret with asterisks but copies the rest of the line as-is, so Radar never indexes that line, never exposes it to the CEL filter, and redacts it from what agents receive through get_resource and search. And when the findings search runs out of time on a large cluster, the result says the search was partial (findings_scan_incomplete) and suggests narrowing with kind: or ns:, so an empty answer doesn't read as "not affected".
The Java4Shell check has no MCP tool of its own. For it and other runtime CVEs there's get_runtime_versions, which reads the runtime versions running images declare (PHP, Node, Python, Go, Java and others), the same evidence the Java4Shell check uses. That also covers cases like the PHP compiled into the official php images, which Trivy doesn't report. A declared version is what the image says, not proof of the binary; the PHP2Shell post covers when you need it.
Who can see which reports
On your laptop with your own kubeconfig, Radar shows what your credentials can read. When Radar runs with sign-in enabled, report kinds are gated per kind the way Secrets are: a user sees a report kind in a namespace only if they may list that kind there, and across all namespaces only with a cluster-wide grant. Being able to see a namespace's Pods isn't enough. That applies in the UI, in search, in resource counts and in MCP.
The reason is the ExposedSecretReport. Its match field quotes the line in the image where Trivy found a secret. Trivy masks the secret itself, but not the text around it, and a masking rule can miss, so Radar guards these reports the way it guards Secrets.
Radar Cloud: search a CVE across every cluster
Radar Cloud runs the same Radar inside each cluster and adds a fleet view. Its search fans one query out to every connected cluster, so a CVE ID in the Cloud search box returns the matching reports from all of them, each labelled with its cluster. The CEL report binding works in fleet filters too, and agents get the same through the Cloud MCP server's fleet_search. Opening a cluster gives you the Vulnerabilities tab, the Java4Shell check and the report views shown above, once its connector runs v1.21.0 or newer; the Java4Shell screenshot above is from a Cloud cluster view. The rollup covers one cluster at a time; Cloud has no fleet-wide vulnerability view. The fleet views docs cover the search scope and cluster picker.
Fleet results identify the report and its cluster. For the package versions and the workload, open the report or search within that cluster.
Cloud's default viewer, member and owner roles can read every Trivy report kind except ExposedSecretReport, across all namespaces. That one is withheld by default because of what match quotes; grant get and list on exposedsecretreports to the people who should see it.
Compared to other vulnerability tools
Radar works next to a scanner and a vulnerability-management platform, not in place of them. Scanners answer which images carry a CVE, before or after deploy. Platforms add the workflow around it: policies, alerts, history, tickets and exploitability scores. Radar answers the questions you have in the cluster during a CVE response:
- Which workloads run it now. Findings count only for containers running now, matched by the digest the kubelet reports, so old revisions and a re-pushed tag don't skew the numbers.
- What it couldn't check. Unscanned images and unassessed containers are listed with the reason, and totals read as lower bounds, so a gap doesn't read as clean.
- The smallest upgrade. By fix picks the lowest listed release that clears every fixable CVE of a package, not just the newest one.
- Facts outside the image. The Java4Shell check combines the image's declared Java version with node CPU labels and the Pod's JVM flags, and it doesn't wait for a vulnerability database update and a rescan.
- Where you act on it. A finding is one click from the workload, its logs and its topology, in the tool you already use for the cluster, and agents get the same data over MCP.
What Radar doesn't do is scan images before deploy, alert on a new CVE, or score exploitability. Keep a scanner and, if you need that workflow, a platform for those.
What it doesn't do
- Scan. A Trivy report is evidence about an image at scan time. A CVE published after the last scan is absent until Trivy rescans with an updated database. With the operator chart's defaults, reports expire after 24 hours (
scannerReportTTL) and the workload is scanned again. - Prove a workload is clean. A missing report isn't a clean one, and neither is a missing Java declaration. The Vulnerabilities tab lists a running image with no report as not scanned yet, and the Java4Shell check lists containers it couldn't assess. But a report larger than the API server's request limit is never written, and Trivy doesn't report software it doesn't recognize, such as the PHP compiled into the official
phpimages. The PHP2Shell post shows both, and the Trivy Operator settings that keep reports small enough. - Keep old ReplicaSets' reports. By default (
vulnerabilityScannerScanOnlyCurrentRevisions: true) Trivy Operator deletes an old ReplicaSet's reports after a rollout. With it set tofalsethey stay, and in REST and MCP results a replica count of 0 usually marks one, though a Deployment scaled to zero also reads 0. - Raise Issues or alerts. Vulnerabilities and Java4Shell matches stay out of Radar's Issues and out of the best-practices score, and nothing notifies anyone of a new critical CVE. You find it by looking, by asking, or with
--fail-on-matchin CI.
Try it
brew install skyhook-io/tap/radar
radar check java4shell -A
radarYou need Radar v1.21.0 or newer for the Java4Shell check and the Vulnerabilities tab, and Trivy Operator in the cluster for everything except the Java4Shell check. The Java4Shell CLI reference covers the flags and exit codes. To give your agent the same search, add Radar's MCP server, for example claude mcp add radar --transport http http://localhost:9280/mcp; the MCP docs cover other clients. The Vulnerabilities docs cover the tab, and the Trivy integration docs list every report kind and the search details.
Radar is open source (Apache-2.0). If the Java4Shell check gets a container wrong, a report renders wrong, or search misses a finding you can see in the YAML, please open an issue on GitHub.
Get the next issue in your inbox
Kubernetes deep-dives, new Radar releases, and what we learned shipping them.
About one email a month. No sales sequences. Unsubscribe anytime.
Questions about this post?Ask in #radar-help on the Radar Slack
Keep reading
Finding PHP2Shell in Kubernetes, Including the PHP Trivy Can't See
PHP2Shell is fixed in PHP 8.2.35, 8.3.36, 8.4.27 and 8.5.12. How to find the Pods still running an older PHP with Radar, including images built on the official php image, where Trivy reports no PHP at all.
Read-Only Is Not a Safety Boundary
Two sentences get said in every meeting where a team wires an AI agent into a cluster: it's read-only, and just use the service account. Both are wrong later.
Give Your Agent Context Before You Buy an AI SRE
We ran the same agent and model on 50 live Kubernetes faults. With read-only cluster context it reached the answer about three times faster, and was slightly more accurate. Here's what it did without that context, and how to run the same test before you buy an AI SRE.