Skip to main content

What validated exploitability means for a container

The evidence behind container exploitability verdicts, and how a tailored profile restricts post-exploitation actions while a vulnerable PHP service is patched.

Hannes Ullman

Hannes Ullman

bifrost security

What validated exploitability means for a container

As a follow up to last week’s post, we wanted to go through how a CVE is actually assessed against a running workload. When a CISO says they want to prioritise by validated exploitability, what does that mean for a container, and what evidence is enough?

Where the term comes from

In a16z’s survey of 100 CISOs at companies with more than 1,000 employees, 67% of respondents want to prioritise remediation using validated exploitability. The article describes attack-path validation: testing establishes what an attacker can reach and which changes would stop the attack.

That is good evidence. Whether testing is periodic or continuous, a successful attack test demonstrates a path under the conditions tested. Developers ship, configurations change, and those conditions need to be checked again.

For containerised workloads, runtime assessment supplies complementary evidence. Here, validation means assessing a vulnerability’s prerequisites and effects against evidence from the workload, its configuration and its permissions. It does not mean executing every exploit against production. This post is about that assessment and where its conclusions stop.

Three questions behind the assessment

The assessment separates three questions that are easy to conflate.

Is the affected code present and loaded? An image scan or SBOM identifies a component. Runtime evidence shows whether the workload executes its binary or loads its library. That is different from establishing that a particular vulnerable function can be reached. An unused CLI tool and a library loaded by the application need different assessments, even when they come from the same package.

Are the vulnerability’s prerequisites and impact path available in this deployment? The affected version, enabled features, configuration and reachable application code matter. Some exploits require a new process or access to a particular file. Others disclose memory or change application data entirely through operations the service already needs.

Which required operations does the enforced profile deny? The assessment checks actual permissions, not just observed behaviour. An operation that has never been observed may still be allowed. Denying an operation required for the vulnerability’s impact is different from allowing that impact but blocking a later attempt to escalate or persist.

bifrost combines runtime behaviour with the SBOM, CVE information and deployment context to assess each vulnerability against each workload. It learns and evaluates behaviour, including weaknesses in operations the service legitimately performs.

The three verdicts, and what places a CVE in each

Reachable. An assessed path to the vulnerability’s impact remains available in this deployment. Where that impact uses only permitted operations, the profile has nothing to deny. Where later escalation or persistence requires operations outside the profile, enforce mode still blocks those operations. Patch urgency follows the remaining exposure and impact.

Mitigated by the profile. The assessment establishes that the applicable paths to the vulnerability’s impact require operations the tailored profile denies. In enforce mode, the kernel refuses those operations. Blocking one public proof of concept is not enough: another payload might use an allowed interpreter, operate in memory or achieve the same impact through a different path. The patch schedule must reflect the assessment’s scope and any remaining exposure, rather than a single blocked attempt.

Never loaded. The affected component is present in the image, but the assessment establishes that its vulnerable code is not loaded in this workload. Observation must be considered alongside deployment configuration and application dependencies. A quiet week is not enough on its own. A code path that runs on the first of the month is still a code path, and an entrypoint that does not name a library does not establish that the application never loads it.

Each conclusion needs a traceable basis: the CVE and affected component, the workload and image, the relevant configuration, the behaviour examined, and the permissions and enforcement mode used in the assessment. Missing evidence is not evidence of protection. If a prerequisite or alternative impact path remains unresolved, it needs further assessment rather than being treated as ruled out.

The verdict belongs to the workload and its context, not to the CVE alone. The same CVE can be mitigated by the profile in one service and reachable in another. Changes to the image, configuration, profile or vulnerability information can change that answer.

PHP2Shell: limiting what happens after exploitation

PHP2Shell shows why a reachable vulnerability and useful runtime protection can coexist. Consider an affected PHP-FPM workload where the CVE-2026-109618 code-execution path described by Calif is reachable. An attacker can execute code inside the PHP worker. That does not require a shell, so blocking /bin/sh alone does not stop the initial impact.

What happens next is where the tailored profile matters. bifrost learns and evaluates the service’s behaviour, then builds a profile around the operations it needs. In enforce mode, the kernel holds the container to those permissions even after the worker is exploited. Compromising the application does not automatically grant it permission to run new programs or access new files.

A PHP service may need to handle requests, read application files and connect to its database. It may have no reason to launch a shell, run a binary from an upload directory or read a platform credential. Where its tailored profile excludes those operations, enforce mode denies them. Attempts to turn code execution into an interactive shell, install additional tools or collect credentials outside the application’s needs are then hindered at the point where they require a denied operation. Each denial is reported with its context.

These restrictions remove routes to persistence, privilege escalation and movement beyond the service. They are not a guarantee that every route is closed. Data and credentials the application can already access remain exposed to code running with its permissions. Connections to other services also need appropriate network controls; the profile alone should not be treated as destination-level egress protection.

The result depends on the workload. If the application legitimately invokes ImageMagick through a shell, its profile may permit that shell launch. The assessment then examines what the shell is allowed to do. A narrow profile for one service can deny an operation that another service needs, which is why the verdict and the remaining exposure belong to the workload, not just the CVE.

For this PHP-FPM example, the verdict remains reachable: patch first. The profile does not repair the PHP flaw or stop every action inside the compromised worker. It restricts the additional actions available while the fix is prepared. That is the distinction: a vulnerability can still need urgent remediation while the enforced profile blocks specific ways of turning it into a wider compromise.

What this looks like in practice

Assessment and enforcement have distinct roles in each mode.

In observe mode, bifrost learns and evaluates workload behaviour and combines it with the SBOM, CVE information and deployment context. Nothing is blocked. Assessments can identify code that is not loaded and operations a proposed profile would deny. Any conclusion about profile-based mitigation remains conditional on that profile being enforced.

In detect mode, oversteps of the tailored profile become alerts with their context, without being blocked by that mode. A shell launch outside the PHP worker’s profile is a concrete deviation from that workload’s permissions, sharper than a generic rule about process execution. Detect is where the team checks the profile against real traffic, on the way to enforce.

In enforce mode, the kernel applies the restrictions used by the assessment. Operations outside the profile are refused before they run. The kernel enforces permissions; it does not decide whether a CVE assessment is correct. A reachable vulnerability still needs remediation, with escalation restricted only where its required operations fall outside the profile.

The survey also found that 70% of respondents want to retest and verify that fixes worked. Deployment tracking and an updated SBOM provide evidence that the fixed component reached the running workload, rather than remaining only in the registry. The assessment is re-evaluated against that workload, and bifrost regenerates the profile with each build; the resulting permissions may remain the same if behaviour has not changed.

That is deployment evidence, not an exploit retest. Repeating an appropriate test checks whether the previously demonstrated path now fails. The two forms of verification answer different questions.

Evidence that follows the workload

Attack-path testing demonstrates an exploit path under the conditions tested. Runtime assessment tracks the workload context and permissions against which that path is assessed. Both can be continuous. Neither makes the other redundant.

bifrost re-evaluates CVEs against the workload context it holds as builds, profiles and vulnerability information change. The useful answer is not only a label: it is the protection status, the scope of the assessment, the remaining exposure and the next action.

Start with one workload. On Kubernetes, one Helm chart gives a first assessment of CVE exploitability in under 10 minutes, from the SBOM, the CVE data and the deployment spec. Observe mode then adds behaviour for further assessment, including what a tailored profile would deny if enforced. Your team decides when to enforce. Book a demo to see the assessment on your own workloads.

Tags

cvevulnerabilityprioritisationruntimeapparmorphpkubernetes

Do you know what's exploitable in your environment?

Deploy bifrost via Helm and it reads how every container is actually deployed, cutting your CVE list before a single line of code changes.