Supply Chain, Container Runtime, and Trust Relationship Attacks

An authorized test begins with an uncomfortable observation. A cloud application is running an image from its approved registry, under its expected workload identity, but the behavior inside the workload doesn’t match the reviewed source. Where did trust fail? This episode expla…

An authorized test begins with an uncomfortable observation. A cloud application is running an image from its approved registry, under its expected workload identity, but the behavior inside the workload doesn’t match the reviewed source. Where did trust fail?

The source repository may have been changed. The build process may have produced an unexpected artifact. Someone may have replaced or altered the image in the registry.

The deployment may have selected the wrong image. The workload may have been compromised only after it started. Or a trusted identity relationship may be allowing actions that nobody intended.

Those aren’t interchangeable explanations. They describe different attack paths, evidence, consequences, and control failures. PenTest+ objective 4.6 includes image and artifact tampering, supply chain attacks, runtime attacks, container escape, and trust relationship abuse. That objective mapping tells you these belong in cloud attack reasoning. It doesn’t mean every suspicious container demonstrates all five, or that finding one permits you to test the others without authorization.

A useful way to separate them is to follow the workload’s provenance. Provenance is the history that connects what was intended to what was built and eventually executed. Start with source, then consider the build process and its output.

Follow that artifact into a registry, from the registry into deployment, and from deployment into the running workload. Finally, examine the identities and trust relationships that let people, services, or workloads act along that path. At each point, ask what was trusted, what evidence supports that trust, and what boundary would have to fail for the observed result to occur.

Image or artifact tampering means the deployable object isn’t the object the organization intended to use. The important evidence must connect a specific artifact to its expected origin and contents. A familiar image name or an approved registry location doesn’t establish that connection by itself. If the source appears correct but the deployed artifact doesn’t correspond to the expected build output, the investigation belongs between source, build, storage, and deployment selection. Calling it a runtime attack too early skips the question of whether the unwanted behavior was already present before execution.

A supply chain attack has a wider frame. It introduces compromise through a product, dependency, build, distribution process, service, or supplier relationship. The immediate symptom might still be a changed artifact, but artifact tampering describes what happened to an object.

Supply chain compromise asks how an upstream relationship or process allowed that condition to reach the organization. NIST supply chain guidance treats this as risk extending across systems and organizations. Evidence of unexpected code in an image may support an artifact finding, but it’s insufficient by itself to identify the supplier, dependency, or build relationship through which the change arrived.

A runtime attack begins against a workload that’s already executing. That distinction changes the evidence you expect. If the approved artifact began in the intended state and unauthorized behavior appeared later, you’d look for observations associated with the running workload, its configuration, privileges, connections, and interactions.

Runtime compromise doesn’t automatically prove the registry was altered. In the other direction, a tampered image doesn’t prove that an attacker later exploited the running container. The initial condition and the later behavior can be connected, but the connection needs evidence.

Container escape is narrower and potentially more consequential. It means breaking a container isolation boundary to gain access to the host or broader environment. A process running inside a container isn’t automatically an escape, even when that process is malicious or uses elevated privileges inside the container. The decisive question is whether activity crossed the isolation boundary. NIST container guidance distinguishes risks involving images, runtime behavior, and isolation, which is why these attack surfaces shouldn’t be collapsed into one generic container problem.

Trust relationship abuse can touch every stage without changing the code directly. A build service may trust a source location. A deployment service may trust a registry. A workload may receive an identity that other cloud services accept.

Abuse occurs when an allowed relationship is used beyond its intended purpose or with more authority than intended. The credentials may be valid and the request may be accepted, yet the action can still violate the organization’s security intent. Evidence must therefore address both authentication and authorization. Showing that an identity was accepted doesn’t establish that its resulting access was appropriate.

Now consider a controlled lab in which a trusted deployment pulls a tampered image. The image starts successfully, and the workload has runtime permissions that could make an isolation failure especially damaging. That combination is serious, but it still doesn’t prove a container escape. What can you support immediately?

You can investigate whether the deployed image differs from the expected artifact, whether the deployment selected that image, and what permissions the workload received. You can describe why those permissions increase the possible impact. You cannot report host compromise merely because host compromise looks possible.

Before taking a stronger action, state a prediction. If the artifact was changed before deployment, evidence should connect the unexpected content to the stored or selected image rather than only to a later runtime modification. If the registry copy is the expected artifact but the running workload differs, the investigation shifts toward deployment configuration or runtime activity. If the workload crossed its isolation boundary, evidence must show access to the host or broader environment, not just control within the container. Each prediction points to a different control boundary.

The next action must also fit the engagement. Confirm the authorized account, project, cluster, registry, image, workload, and testing window. Identify dependencies and likely operational impact.

Cloud services are shared and interconnected, so a technically possible action may reach resources or third parties that aren’t in scope. Provider responsibilities and customer responsibilities also vary by service. That makes the exact target and permitted activity more important than a general statement that cloud testing has been approved.

Suppose the rules permit inspection and evidence collection but don’t clearly permit an active escape attempt. The correct response isn’t to assume that container testing includes the host. Use the lower-impact evidence that the engagement allows.

Establish the artifact discrepancy, record the workload permissions, and explain the unresolved escape condition. Then seek clarification if stronger validation is necessary. A technically clever action outside the target, timing, or operational constraints is still the wrong penetration-testing decision.

This process can be expressed as five connected steps. Begin with the requirement and the observed condition. Predict what evidence should exist if your hypothesis is true. Choose a bounded action that can collect that evidence.

Compare the result with the prediction. Then document what’s supported, what has been ruled out, and what remains uncertain. The value comes from the links between those steps. An isolated tool result can be useful evidence, but it isn’t automatically a validated finding.

Imagine that an inspection reports a vulnerable software package inside the container. Someone concludes that the container has been escaped. That conclusion fails because the observation and the claimed impact concern different boundaries. The package finding says that a component inside the image or workload has a known weakness.

It may create an opportunity for compromise within the container, depending on conditions that still need validation. A container escape says the isolation boundary was actually broken, giving access to the host or a broader environment. One doesn’t prove the other.

To expose that mistaken assumption, ask what observation demonstrates boundary crossing. Evidence limited to package identity, version, or activity inside the container can support a package or workload finding. It doesn’t demonstrate host access.

Likewise, seeing a process with broad authority inside its container doesn’t establish that the process reached outside it. You need to identify the claimed boundary first, then seek evidence that corresponds to crossing that boundary. If the engagement doesn’t authorize that validation, report the risk and limitation without manufacturing certainty.

Conflicting evidence deserves troubleshooting before escalation. Suppose the expected artifact record and registry artifact appear consistent, but the running workload behaves unexpectedly. Don’t immediately declare the registry compromised. Confirm that you inspected the correct registry location, deployment, workload, and point in time.

Check whether your evidence is current and whether the observation depended on privileges or prerequisites that weren’t present. A stale result, wrong target, or incomplete view can imitate a security discrepancy. Those possibilities don’t eliminate the concern, but they change what you can responsibly claim.

Now reverse the conflict. The running workload appears ordinary, but the stored artifact differs from the expected build output. Lack of observed malicious runtime behavior doesn’t make the artifact trustworthy. The unexpected content may not have executed during your observation window, or the visible behavior may not reveal its purpose.

Stay with the supported finding. The artifact’s provenance is broken. Whether that condition produced runtime compromise is a separate question requiring separate evidence.

Trust evidence can conflict in a similar way. A log may show that an approved workload identity requested access successfully. That supports the identity involved and the accepted action, assuming the log is authentic and applicable.

It doesn’t tell you that the relationship granted only the intended access. To evaluate trust abuse, compare the observed action with the authority the workload was supposed to have. If the same identity can act across a broader environment than the engagement expected, the failed boundary may be the trust policy rather than the image, registry, or container isolation layer.

This is why remediation should follow the failed boundary instead of the most dramatic possible outcome. When provenance fails between source and build, the response belongs around that part of the supply chain. When the stored artifact doesn’t match the approved output, artifact integrity and distribution controls are central.

When the approved artifact is altered or exploited only after starting, runtime controls and workload configuration deserve attention. When activity crosses container isolation, the isolation boundary and permissions are directly involved. When valid identities obtain unintended authority, the trust relationship needs correction.

These categories can overlap. A compromised dependency could enter through the supply chain, become part of a tampered build artifact, run inside a deployed container, and use an overly broad workload identity. If an additional weakness permits host access, container escape joins the chain. Reporting one long attack story can help explain overall risk, but each link still needs its own evidence. If only the first two links are validated, the remaining links are plausible impact paths, not observed facts.

Your evidence record should preserve those distinctions. Identify the artifact or workload you examined, the expected state, the observed state, and the basis for comparing them. Record the authorized action used to validate the condition.

Explain the affected boundary and the demonstrated impact. If impact depends on permissions, configuration, or another untested weakness, name that dependency. That lets a reviewer distinguish an observation, a validated finding, and a possible escalation path without guessing what you meant.

Cleanup matters as well, even in a controlled environment. A test can create artifacts, alter workload state, or produce access that should not remain after validation. The exact cleanup depends on what the engagement authorized and what was changed. The essential point is that testing shouldn’t leave an unexpected image, running workload, or trust condition behind. Documentation should show what was introduced or modified and whether it was restored, rather than assuming that a temporary lab action disappears on its own.

Consider another authorized case. A deployment uses the expected artifact, and the workload hasn’t shown evidence of host access. However, its accepted identity can reach a cloud resource outside the intended application boundary. Two actions seem plausible.

You could attempt to use that access broadly to measure the maximum reach, or you could first validate the trust relationship with the least disruptive permitted request and compare the result with the documented intent. The second choice is stronger when broad use isn’t clearly authorized. It tests the relevant boundary without silently expanding the target.

What information could change that choice? Explicit authorization for broader validation could permit additional testing. Evidence that the resource belongs to a third party could prohibit it.

Operational sensitivity or timing restrictions could require coordination even when the account is nominally in scope. A clearer trust policy could also show that the access was intended, turning the initial observation into expected behavior rather than a finding. The technical result and the engagement context have to be interpreted together.

The same reasoning applies when a tampered image has dangerous runtime permissions. One tempting choice is to try an escape immediately because it would show severe impact. The better initial choice is usually the bounded one that tests the earliest unsupported link. Confirm the artifact discrepancy and the deployed identity of the image.

Establish the relevant permissions. Determine whether escape validation is authorized and necessary. If lower-impact evidence already supports a useful finding, don’t add operational risk merely to make the demonstration more dramatic.

This approach also improves remediation. A recommendation to secure containers is too broad to be useful when the actual failure is an untrusted build input. A recommendation to fix the registry misses a runtime-only compromise.

Reducing workload authority may limit impact, but it doesn’t restore a broken artifact provenance chain. Strengthening isolation may address escape risk, but it doesn’t remove a vulnerable package from the image. Precise findings make it possible to place a corrective action at the boundary that actually failed.

When you face a cloud attack scenario involving source, build, registry, deployment, runtime, and identity, resist the urge to jump straight to the most serious outcome. Trace the path in order, but let the evidence tell you where to focus. Ask whether the unexpected condition existed before execution, appeared during execution, crossed isolation, or used trusted authority in an unintended way.

Then choose a validation that fits both the hypothesis and the written engagement constraints. That produces something more valuable than an impressive test action. It produces a conclusion another person can review, reproduce, and use.

Artifact tampering, supply chain compromise, runtime attack, container escape, and trust abuse can appear in the same incident, but they don’t prove one another. A defensible assessment follows the workload from its expected source and build output through the registry, deployment, running environment, isolation boundary, and identity relationships. At each stage, match the evidence to the mechanism you’re claiming. Then use the least disruptive authorized action that can confirm or reject that claim. When you preserve those boundaries in your notes and report, you can distinguish what was observed from what was demonstrated, place remediation where trust actually failed, and describe unresolved impact without overstating it.

Pause and decide: Where did trust fail? Consult the companion episode reference for exact terminology, named tools or standards, source-derived evidence checkpoints, and review material for Container Image Tampering, Supply Chains, Runtime Attacks, and Trust Abuse. This lesson was produced by Bare Metal Cyber dot com.

Supply Chain, Container Runtime, and Trust Relationship Attacks

headphones Listen Anywhere

More Options »
Broadcast by