What it does. Detects unauthorized runtime drift in containers by monitoring binary execution, filesystem changes, and configuration deviation from the original immutable image, using Falco and Microsoft Defender for Containers. Use when validating immutable-infrastructure controls, hunting for unexpected package installs or binaries written inside a running container, or determining whether a container diverged from the image it was built from. Keywords: drift, immutable infrastructure, new binary executed, package install, image mismatch, Falco. Do not use for detecting breakout from the container to the host - use detecting-container-escape-attempts. Part of mukul975/Anthropic-Cybersecurity-Skills (817 security skills) (mukul975/Anthropic-Cybersecurity-Skills).

Upstream	mukul975/Anthropic-Cybersecurity-Skills
Skill file	skills/detecting-container-drift-at-runtime/SKILL.md
License	Apache-2.0 (skill folder LICENSE)
Author	mukul975
Fetched	2026-09-10

Install

• npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill detecting-container-drift-at-runtime, or copy the skill folder into ~/.claude/skills/detecting-container-drift-at-runtime/.
• Raw file: curl -sL https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/HEAD/skills/detecting-container-drift-at-runtime/SKILL.md

SKILL.md (verbatim)

name: detecting-container-drift-at-runtime
description: >-
  Detects unauthorized runtime drift in containers by monitoring binary execution, filesystem
  changes, and configuration deviation from the original immutable image, using Falco and
  Microsoft Defender for Containers. Use when validating immutable-infrastructure controls,
  hunting for unexpected package installs or binaries written inside a running container, or
  determining whether a container diverged from the image it was built from. Keywords: drift,
  immutable infrastructure, new binary executed, package install, image mismatch, Falco. Do
  not use for detecting breakout from the container to the host - use
  detecting-container-escape-attempts.
domain: cybersecurity
subdomain: container-security
tags:
- container-drift
- runtime-security
- immutable-containers
- falco
- kubernetes
- container-security
- drift-detection
- microsoft-defender
version: '1.0'
author: mahipal
license: Apache-2.0
nist_csf:
- PR.PS-01
- PR.IR-01
- ID.AM-08
- DE.CM-01
mitre_attack:
- T1610
- T1611
- T1609
- T1525

Detecting Container Drift at Runtime

Overview

Container drift occurs when running containers deviate from their original image state through unauthorized file modifications, unexpected binary execution, configuration changes, or package installations. Since containers should be treated as immutable infrastructure, any drift is a potential indicator of compromise. Detection techniques leverage the DIE (Detect, Isolate, Evict) model -- an immutable workload should not change during runtime, so any observed change is potentially evidence of malicious activity.

When to Use

• When investigating security incidents that require detecting container drift at runtime
• When building detection rules or threat hunting queries for this domain
• When SOC analysts need structured procedures for this analysis type
• When validating security monitoring coverage for related attack techniques

Prerequisites

• Kubernetes cluster v1.24+ with runtime security tooling
• Falco or Sysdig for runtime drift detection
• Container image registry with image manifests available
• Familiarity with Linux filesystem layers and OverlayFS

Core Concepts

Types of Container Drift

1. Binary drift: Execution of binaries not present in the original image (downloaded malware, compiled tools)
2. File drift: Creation, modification, or deletion of files in the container filesystem
3. Configuration drift: Changes to environment variables, mounted secrets, or runtime parameters
4. Package drift: Installation of new packages via apt, yum, pip, or npm at runtime
5. Network drift: New listening ports or outbound connections not expected for the workload

Detection Methods

Image-Based Comparison: Compare the running container's filesystem against its source image to identify added, modified, or removed files.

Behavioral Monitoring: Use eBPF or kernel-level monitoring to detect process execution, file access, and network activity that deviates from expected behavior.

Digest Verification: Continuously verify that running container image digests match the approved deployment manifests.

Implementation with Falco

Detecting New Binary Execution

- rule: Drift Detected (Container Image Modified Binary)
  desc: Detect execution of a binary not present in the original container image
  condition: >
    spawned_process and
    container and
    not proc.pname in (container_entrypoint) and
    proc.is_exe_upper_layer = true
  output: >
    Drift detected: new binary executed in container
    (user=%user.name command=%proc.cmdline container=%container.name
     image=%container.image.repository:%container.image.tag
     exe_path=%proc.exepath)
  priority: WARNING
  tags: [container, drift]

- rule: Container Shell Spawned
  desc: Detect interactive shell in a container that should be immutable
  condition: >
    spawned_process and
    container and
    proc.name in (bash, sh, dash, zsh, csh, ksh) and
    not proc.pname in (container_entrypoint)
  output: >
    Shell spawned in container (user=%user.name shell=%proc.name
     container=%container.name image=%container.image.repository)
  priority: WARNING
  tags: [container, drift, shell]

Detecting Package Manager Usage

- rule: Package Manager Execution in Container
  desc: Detect use of package managers indicating drift
  condition: >
    spawned_process and
    container and
    proc.name in (apt, apt-get, yum, dnf, apk, pip, pip3, npm, gem, cargo)
  output: >
    Package manager executed in container (user=%user.name
     command=%proc.cmdline container=%container.name
     image=%container.image.repository)
  priority: ERROR
  tags: [container, drift, package-manager]

Detecting File System Modifications

- rule: Container File System Write
  desc: Detect writes to container upper layer filesystem
  condition: >
    open_write and
    container and
    fd.typechar = 'f' and
    not fd.name startswith /tmp and
    not fd.name startswith /var/log and
    not fd.name startswith /proc
  output: >
    File write in container (user=%user.name file=%fd.name
     container=%container.name)
  priority: NOTICE
  tags: [container, drift, filesystem]

Implementation with Kubernetes Enforcement

Read-Only Root Filesystem

Prevent drift by making container filesystems immutable:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: immutable-app
spec:
  template:
    spec:
      containers:
        - name: app
          image: app:v1.0@sha256:abc123...
          securityContext:
            readOnlyRootFilesystem: true
            allowPrivilegeEscalation: false
            runAsNonRoot: true
          volumeMounts:
            - name: tmp
              mountPath: /tmp
            - name: cache
              mountPath: /var/cache
      volumes:
        - name: tmp
          emptyDir:
            sizeLimit: 100Mi
        - name: cache
          emptyDir:
            sizeLimit: 50Mi

Pod Security Standards Enforcement

apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/warn: restricted

Image Digest Verification

Continuous Digest Monitoring

#!/bin/bash
# Compare running container digests against approved manifest

NAMESPACE="production"

kubectl get pods -n "$NAMESPACE" -o json | jq -r '
  .items[] |
  .spec.containers[] |
  "\(.image) \(.imageID)"
' | while read IMAGE IMAGE_ID; do
  APPROVED_DIGEST=$(kubectl get deploy -n "$NAMESPACE" -o json | \
    jq -r ".items[].spec.template.spec.containers[] | select(.image==\"$IMAGE\") | .image")

  if [[ "$IMAGE" != *"@sha256:"* ]]; then
    echo "[WARN] Container using mutable tag: $IMAGE"
  fi
done

Microsoft Defender for Containers Integration

For Azure Kubernetes environments, Microsoft Defender provides built-in binary drift detection:

{
  "alertType": "K8S.NODE_ImageBinaryDrift",
  "severity": "Medium",
  "description": "Binary executed that was not part of the original container image",
  "remediationSteps": [
    "Investigate the binary origin and purpose",
    "Check if the container was compromised",
    "Rebuild the container from a clean image",
    "Enable readOnlyRootFilesystem"
  ]
}

Drift Response Playbook

1. Detect: Alert fires on drift event (Falco, Defender, Sysdig)
2. Validate: Confirm the drift is not from an approved process (init containers, config reloads)
3. Isolate: Apply a deny-all NetworkPolicy to the affected pod
4. Investigate: Capture container filesystem diff and process list
5. Evict: Delete the drifted pod (ReplicaSet will recreate from clean image)
6. Remediate: Fix the root cause (patch vulnerability, update image, tighten RBAC)

References

• Container Drift Detection with Falco - Sysdig
• Microsoft Defender for Containers Drift Detection
• Ensure Immutability of Containers at Runtime
• Falco Runtime Security

Other files in this skill

• LICENSE
• assets/template.md
• references/api-reference.md
• references/standards.md
• references/workflows.md
• scripts/agent.py
• scripts/process.py

assets/template.md (verbatim)

Container Drift Detection Assessment Template

Environment

Field	Value
Cluster Name
Namespaces Assessed
Detection Tool
Assessment Date

Drift Detection Coverage

• Binary execution monitoring enabled
• File system change monitoring enabled
• Package manager usage detection enabled
• Image digest verification enabled
• ReadOnlyRootFilesystem enforced
• Pod Security Standards in enforce mode

Findings Summary

Severity	Count	Remediated
Critical
High
Medium
Low

Sign-Off

Role	Name	Date
Security Engineer
Platform Lead

references/api-reference.md (verbatim)

API Reference: Detecting Container Drift at Runtime

Docker SDK for Python

import docker
client = docker.from_env()

# List running containers
containers = client.containers.list()

# Get container details
container = client.containers.get("container_id")
container.attrs         # full inspection dict
container.image.id      # image SHA256
container.image.tags    # ['app:v1.0']

# Filesystem diff (vs original image)
diff = container.diff()
# Returns: [{"Path": "/tmp/new_file", "Kind": 1}]
# Kind: 0=Modified, 1=Added, 2=Deleted

# Container inspection fields
container.attrs["HostConfig"]["Privileged"]       # bool
container.attrs["HostConfig"]["ReadonlyRootfs"]   # bool
container.attrs["Config"]["Image"]                # image reference

Docker CLI Commands

# Filesystem changes since creation
docker diff <container>     # A=Added, C=Changed, D=Deleted

# Running processes
docker top <container> -eo pid,user,comm,args

# Image digest verification
docker inspect --format='{{.Image}}' <container>

Falco Drift Detection Rules

# Detect binary not in original image
condition: spawned_process and container and proc.is_exe_upper_layer = true

# Detect package manager usage
condition: spawned_process and container and proc.name in (apt, yum, pip, npm)

# Detect shell spawn
condition: spawned_process and container and proc.name in (bash, sh, dash)

Kubernetes Security Context

securityContext:
  readOnlyRootFilesystem: true     # prevent drift
  allowPrivilegeEscalation: false
  runAsNonRoot: true
  capabilities:
    drop: ["ALL"]

Drift Severity Classification

Indicator	Severity
Privileged container	CRITICAL
Sensitive file modified (/etc/shadow)	CRITICAL
Binary added to system path	HIGH
Package manager executed	HIGH
Root shell active	MEDIUM
Mutable root filesystem	MEDIUM

CLI Usage

python agent.py --container my-app-container
python agent.py --container abc123 --all

references/standards.md (verbatim)

Standards and References - Container Drift Detection

Industry Standards

NIST SP 800-190: Application Container Security Guide

• Section 3.3: Containers modified at runtime indicate compromise
• Section 4.2: Monitor containers for unauthorized changes
• Recommends treating containers as immutable infrastructure

CIS Kubernetes Benchmark v1.9

• Control 5.2.8: Minimize container readOnlyRootFilesystem
• Control 5.7.3: Apply security contexts to pods
• Control 5.7.4: Default namespace restrictions

MITRE ATT&CK for Containers

• T1610: Deploy Container -- unauthorized container deployment
• T1611: Escape to Host -- container boundary violation
• T1059.004: Unix Shell execution in containers
• T1105: Ingress Tool Transfer -- downloading tools into containers

Compliance Mapping

Requirement	Framework	Drift Detection Capability
Change detection	PCI DSS 11.5	File integrity monitoring in containers
Unauthorized software	SOC 2 CC6.8	Binary execution drift alerts
Configuration management	ISO 27001 A.12.1	Image digest verification
Incident detection	NIST CSF DE.CM-7	Runtime behavioral anomaly detection

references/workflows.md (verbatim)

Workflows - Container Drift Detection

Detection Workflow

1. Container image deployed with known-good state
2. Runtime monitor (Falco/Sysdig) tracks all process executions and file changes
3. Events compared against baseline: original image manifest + expected runtime behavior
4. Drift events classified by severity (binary drift = HIGH, config drift = MEDIUM)
5. Alerts sent to SIEM/SOC with full container context
6. Automated response: isolate pod network, capture forensics, evict pod

Implementation Phases

Phase 1: Visibility (Weeks 1-2)

• Deploy Falco with drift detection rules in alert-only mode
• Collect baseline of normal container behavior per workload
• Identify legitimate runtime changes (log files, temp files, caches)
• Create allowlists for expected runtime modifications

Phase 2: Detection (Weeks 3-4)

• Enable drift detection alerts with tuned thresholds
• Integrate with SIEM for correlation and dashboarding
• Build runbooks for drift investigation
• Conduct tabletop exercises with container drift scenarios

Phase 3: Prevention (Weeks 5-8)

• Enable readOnlyRootFilesystem on all production workloads
• Deploy Pod Security Standards in enforce mode
• Implement image digest pinning in all manifests
• Enable automated pod eviction for confirmed drift events

Incident Response for Drift Events

1. Triage: Is the drift from a legitimate operation or potential compromise?
2. Contain: Apply NetworkPolicy deny-all to affected pod
3. Collect: Capture container filesystem diff, process tree, network connections
4. Analyze: Compare drifted files against malware signatures and IoCs
5. Remediate: Delete compromised pod, scan all pods in namespace
6. Recover: Deploy clean image, verify no persistence mechanisms

Back to mukul975/Anthropic-Cybersecurity-Skills (817 security skills) or Agent skills.