Skip to content

Observe behavior after admission

Admission evaluates claims about an image before accepting a workload request. Once the program runs, it can receive inputs, encounter vulnerabilities, or be accessed by an operator. A correctly admitted artifact can therefore produce behavior the release process did not anticipate. Runtime observation addresses that different question.

The gap after admission
  • Admitted workload

    Admission permits creation; behavior can still be undesirable.

  • Process event

    Modern eBPF exposes container/process events.

  • Falco detects

    Configured shell rule records an event after execution.

  • Optional routing

    External Pub/Sub/function/Discord delivery is unverified.

  • Admitted workload Process eventprocess executes
  • Process event Falco detectsrule selects event
  • Falco detects Optional routingoptional; disabled by defaultOptional / unverified
Falco shell detection is observation. Optional external alerting is disabled by default and delivery is unverified.
Text equivalent and limits
  1. A correctly admitted image can later execute undesirable behavior.
  2. Modern eBPF exposes process/container events to the running Falco sensor.
  3. The custom rule selects shell process events in containers outside kube-system and falco-system; its name does not establish cryptographic signature checks.
  4. Falcosidekick receives events; optional Pub/Sub/function routing needs explicit enablement and separate delivery evidence.

Read the labeled relationships as the stated contract. Optional connections are dashed and explicitly labeled; comparisons do not imply a sequential handoff. This figure explains inspected code or recorded observations, not current cloud execution.

The production Falco configuration defines Shell Spawned In Signed Workload Pod. Its actual condition is a spawned process in a container whose process name belongs to shell_binaries, excluding kube-system and falco-system. Output includes user, Pod, namespace, container, image repository, and command line, with CRITICAL priority.

The title reflects the intended deployment story. The rule does not look up a Cosign signature, check the selected digest, or confirm a prior admission decision. It can detect a matching shell in an unsigned workload outside admission’s image scope. Conversely, malicious behavior without a matching shell event may be outside this rule. Use the condition to understand the guarantee instead of deriving it from the rule name.

The Falco module installs the chart with the configured eBPF driver, Kubernetes metadata collection, custom rules, and rule_matching: all. The historical notes explain that first-match processing allowed a broad default rule to prevent this custom rule from being evaluated for the same event. The stored setting ensures all matching rules can produce their observations; it does not make detection exhaustive.

Detection was observed, prevention was not

Section titled “Detection was observed, prevention was not”

The owner validation record reports a controlled kubectl exec shell with sh -c id and a CRITICAL custom-rule event. The shell command executed. The evidence therefore supports detection, not blocking or automatic containment.

The final image contains a slim distribution runtime and the controlled test demonstrates shell availability. Hardening removes the build-stage compiler and constrains privileges/filesystem behavior; it is inaccurate to say the runtime has no interactive shell. Non-root execution, read-only filesystem, seccomp, and dropped capabilities reduce avenues of harm, but still permit the tested process behavior.

The sample application’s /info is not a verifier. Its source returns signed: true as a constant and defaults IMAGE_DIGEST to unknown. The historical Helm template does not inject that variable. Use registry verification and Kubernetes image selection, not that self-reported boolean, as artifact evidence.

Recorded execution · detected

The shell executed as UID/GID 10001 and a Critical Falco event was then recorded.

Recorded result: The command returned id output and Falco logs showed the named Critical shell rule.

The controlled shell returns UID/GID 10001; Falco subsequently records a Critical shell event.
The controlled shell returns UID/GID 10001; Falco subsequently records a Critical shell event. Select the image for full resolution.

Key limitation: Detection happened after successful shell execution; no prevention or automatic termination observed.

Transcript and provenance

Expected in this setup: Record unexpected shell execution in the application namespace with the configured Falco rule.

Historical GCP, europe-west1; current environment not checked · observed 2026-08-23 · source revision unknown; not inferred from the documentation baseline

Selected visible output:
uid=10001(appuser) gid=10001(appgroup) groups=10001(appgroup)
"priority": "Critical"
"rule": "Shell Spawned In Signed Workload Pod"
Critical Unexpected shell spawned in hardened pod
user=appuser
ns=default
cmdline=sh -c id
RESULT: PASS - Falco detected the controlled runtime shell
Full limitations
  • Detection happened after successful shell execution; no prevention or automatic termination observed.
  • The rule condition does not verify signatures.
  • The captured image tag does not establish a manifest digest or build commit.
  • No external notification or incident-response completion captured.

Visual review of original capture. Collection capture date attributed to docs/my-validation/README.md; this task did not rerun its cloud experiment. The original screenshot is approved for display at the owner’s explicit request for all evidence images and subsequent Cloudflare publication. Original terminal metadata remains visible. No additional pixel redaction was selected or applied. The selected transcript omits incidental prompts without changing the recorded result.

Read the approved selected-output transcript →

Inspect the related gallery capture →

Inspect the untouched, commit-pinned original →

The observed command completed before the sensor log was inspected. Its event metadata does not establish a manifest digest, so it should not borrow the acceptance screenshot’s digest to create a complete artifact-to-runtime trace.

The module enables Falcosidekick, but the alerting resources are conditional on enable_runtime_alerting, whose default is false. When deliberately enabled, the defined path is Falco → Falcosidekick → Pub/Sub → Cloud Function → Discord. Falcosidekick uses a Kubernetes ServiceAccount bound to a topic-level publisher GSA; the Discord URL flows to Secret Manager through the alerting module.

The record explicitly says no Discord alert was captured because that path was disabled. Installed sidekick replicas do not prove external delivery. Enabling the code later would require a real owned destination, appropriate secret handling, and a delivery test; it cannot be inferred from the Terraform definition or the local shell event.

Not verified · gap

Discord delivery and incident response were not demonstrated in the recorded validation.

Recorded result: The validation README says the alerting path was disabled pending a real webhook; no Discord capture.

Key limitation: Optional Terraform resources do not establish enabled deployment.

Transcript and provenance

Expected in this setup: Only an enabled, configured and executed alert test could establish external delivery.

Historical optional GCP alerting path; disabled per validation README · observed date unknown · source revision unknown; not inferred from the documentation baseline

Recorded statement: No Discord alert was captured because the alerting path is disabled until a real webhook is supplied.
Full limitations
  • Optional Terraform resources do not establish enabled deployment.
  • A runtime log alone does not prove event delivery or response.

Source inspected against the pinned baseline; execution scope stated explicitly. No screenshot or sensitive runtime state published.

Inspect the untouched, commit-pinned original →

A CRITICAL record should prompt investigation of the process, identity, selected artifact, and relevant deployment changes. This baseline does not attach an automated kill/quarantine action to the rule. Guidance for response in cleanup and response distinguishes source-backed historical operations from added, untested operational reasoning.

Read the controlled runtime evidence for the particular observation and its limits. The release journey ends with an admitted artifact, but the security responsibilities continue through observation, interpretation, and deliberate response.