Ask a KCSA candidate what MITRE ATT&CK is and most will say “a framework of attacker tactics and techniques”, which is correct and almost useless on exam day. The questions that actually appear do not ask you to define ATT&CK. They describe a behaviour, such as “an attacker with access to a Pod runs kubectl auth can-i --list and kubectl get secrets -A”, and ask which tactic that is, or they name a technique like Escape to Host and ask which Kubernetes control prevents it, or they ask which framework you would use to check whether your detections cover real adversary behaviour against containers. To answer those you need the matrix itself in your head: the ten tactic columns, the handful of techniques in each, what each technique looks like as a Kubernetes API call or Pod spec, and what stops it.
This guide walks the Containers matrix cell by cell as it stands in ATT&CK v20.1, released on 13 October 2026. That matters more than usual this year, because ATT&CK v19 (28 April 2026) made the biggest structural change in the framework’s history: the Defense Evasion tactic was split into two, Stealth and Defense Impairment, so Enterprise ATT&CK now has 15 tactics and the Containers matrix has 10 columns instead of 9. Study material written before mid-2026, including most KCSA notes in circulation, still lists Defense Evasion. The exam is unlikely to penalise the old name, but you should recognise the new ones and understand why the split was made, because the distinction between hiding and breaking defenses is exactly the kind of conceptual line the KCSA likes to test.
Two existing guides frame this one. The KCSA threat model guide covers the six attacker goals the curriculum names (persistence, privilege escalation, denial of service and lateral movement, malicious code in containers, access to sensitive data, attacker on the network) and STRIDE. The compliance and security frameworks guide places ATT&CK next to CIS, NIST and SLSA and gives it a page. Neither opens the matrix. This article does, and then maps every cell back to those six goals so the two views reinforce each other.
How to read an ATT&CK matrix
Four vocabulary items carry the whole framework:
- Tactic is the adversary’s why at a given moment: get in, run code, stay in, get more privilege, hide, break defenses, steal credentials, look around, move, cause damage. Tactics are the column headers and have
TAidentifiers (Initial Access isTA0001). - Technique is how they achieve a tactic. Techniques have
Tidentifiers (T1611is Escape to Host) and a technique can appear under several tactics when the same behaviour serves several goals. - Sub-technique is a more specific variant, written
T1053.007(Scheduled Task/Job: Container Orchestration Job). The Containers matrix shows sub-techniques where only some variants of a parent technique apply to containers. - Platform is the environment a technique applies to. Containers is a platform within Enterprise ATT&CK, alongside Windows, Linux, macOS, the cloud platforms and others. The Containers matrix is simply the Enterprise matrix filtered to techniques tagged with that platform. There is no separate “Kubernetes matrix” in ATT&CK; Kubernetes, Docker and other runtimes are all described under Containers.
Each technique page carries a description, procedure examples from real intrusions, mitigations (with M identifiers such as M1047 Audit or M1026 Privileged Account Management), and since v18 detection strategies with analytics describing what telemetry would reveal the technique. For the KCSA you need the tactic and technique layer; the mitigation and detection layers are where the matrix becomes a working tool, which the final sections cover.
The ten tactics of the Containers matrix in v20.1
| Column | Tactic | ID | The adversary is trying to… | Techniques in the Containers matrix |
|---|---|---|---|---|
| 1 | Initial Access | TA0001 | get into your cluster | 3 (Exploit Public-Facing Application; External Remote Services; Valid Accounts: Default Accounts, Local Accounts) |
| 2 | Execution | TA0002 | run adversary-controlled code | 5 (Container CLI/API; Container Administration Command; Deploy Container; Container Orchestration Job; Malicious Image) |
| 3 | Persistence | TA0003 | maintain their foothold | 7 (Additional Container Cluster Roles; Local Account; Container Service; External Remote Services; Implant Internal Image; Container Orchestration Job; Valid Accounts) |
| 4 | Privilege Escalation | TA0004 | gain higher-level permissions | 6 (Additional Container Cluster Roles; Container Service; Escape to Host; Exploitation for Privilege Escalation; Container Orchestration Job; Valid Accounts) |
| 5 | Stealth (new in v19) | TA0005 | hide and conceal their actions, appearing as normal behaviour | 4 (Build Image on Host; Indicator Removal; Masquerading: Match Legitimate Resource Name or Location, Masquerade Account Name; Valid Accounts) |
| 6 | Defense Impairment (new in v19) | TA0112 | break security mechanisms, pipelines and tooling so defenders cannot see or trust what is happening | 1 (Disable or Modify Tools) |
| 7 | Credential Access | TA0006 | steal account names and passwords or tokens | 3 (Brute Force: Password Guessing, Password Spraying, Credential Stuffing; Steal Application Access Token; Unsecured Credentials: Credentials In Files, Container API) |
| 8 | Discovery | TA0007 | figure out your environment | 3 (Container and Resource Discovery; Network Service Discovery; Permission Groups Discovery) |
| 9 | Lateral Movement | TA0008 | move through your environment | 1 (Use Alternate Authentication Material: Application Access Token) |
| 10 | Impact | TA0040 | manipulate, interrupt or destroy systems and data | 5 (Data Destruction; Endpoint Denial of Service; Inhibit System Recovery; Network Denial of Service; Resource Hijacking: Compute Hijacking, Bandwidth Hijacking) |
Two tactics from Enterprise do not appear in the Containers matrix at all: Reconnaissance and Resource Development (the pre-intrusion tactics), and Collection, Command and Control and Exfiltration have no container-tagged techniques. If an exam option names one of those for a container scenario, it is a distractor. Note also that Valid Accounts and Container Orchestration Job sit in several columns at once; that is not a mistake, it is the point: a stolen credential gets you in, keeps you in, and may escalate you, depending on what the credential can do.
Why Defense Evasion was split
The ATT&CK team’s reasoning, published with v19, is that the old Defense Evasion column mixed two fundamentally different behaviours. Stealth is concealment without touching the defenses: naming your malicious DaemonSet kube-proxy-v2, deleting your own Pods and Events after use, or logging in with a legitimate stolen account so nothing looks anomalous. Defensive systems are left intact; the adversary just does not trip them. Defense Impairment is direct interference with the defenses: killing the Falco DaemonSet, deleting the audit policy, removing a ValidatingWebhookConfiguration, turning off log forwarding. The defenses are degraded or no longer trustworthy. The two call for different responses (better analytics versus tamper protection and integrity monitoring), which is why they are now separate tactics. For the KCSA, if a scenario describes an attacker disabling something, it is Defense Impairment; if it describes an attacker blending in, it is Stealth.
Tactic 1: Initial Access
T1190 Exploit Public-Facing Application. In Kubernetes this is two things. First, a vulnerability in your workload (an injection flaw, deserialisation bug or SSRF in a web app behind an Ingress) that gives the attacker code execution inside a Pod. That Pod is the beachhead for everything below. Second, an exposed cluster surface: an API server reachable from the internet with anonymous authentication enabled, an unauthenticated kubelet on port 10250, or a dashboard with a permissive ServiceAccount. Controls: keep the API server off the public internet or behind an authenticating proxy; disable anonymous access where you can (the CKS authentication guide covers the anonymous.conditions nuance); set the kubelet to authentication.anonymous.enabled: false and authorization.mode: Webhook; scan and patch images; put a WAF or Ingress-level filtering in front of applications.
T1133 External Remote Services. Remote management surfaces that should not be external: the kubelet API, kubectl proxy left running on a jump host, an etcd client port exposed without mutual TLS, a CI runner with a cluster-admin kubeconfig reachable from the internet, or a VPN or bastion with weak authentication. Controls: network policy and firewalling of ports 6443, 2379 to 2380 and 10250; mutual TLS on etcd; no kubeconfigs on internet-facing hosts.
T1078.001 Valid Accounts: Default Accounts. Every namespace has a default ServiceAccount, and until you set automountServiceAccountToken: false every Pod that does not name another account gets its token mounted at /var/run/secrets/kubernetes.io/serviceaccount/token. If someone has bound that account to a Role, the attacker who lands in the Pod inherits it. Default credentials baked into container images (a database image with its vendor password) are the same technique. Controls: disable token automount, bind nothing to default, scan images for embedded credentials.
T1078.003 Valid Accounts: Local Accounts. A stolen kubeconfig, an exported long-lived ServiceAccount token Secret, or a leaked client certificate. These authenticate as a legitimate identity, so nothing in the authentication layer objects; this is why Valid Accounts also appears under Persistence, Privilege Escalation and Stealth. Controls: short-lived credentials (bound ServiceAccount tokens, OIDC with short token lifetimes, certificate rotation), no legacy kubernetes.io/service-account-token Secrets, audit logging of where identities authenticate from.
Tactic 2: Execution
T1059.013 Command and Scripting Interpreter: Container CLI/API. The newest execution entry recognises that kubectl, the Kubernetes API and the Docker CLI are themselves interpreters an adversary drives: pulling or building images, running containers, executing commands inside them, and listing resources, all through legitimate tooling. In Kubernetes terms this is simply using the API with a credential you should not have. Controls: least-privilege RBAC so the credential cannot do much; audit logging so the calls are recorded.
T1609 Container Administration Command. Executing a command in a running container through the orchestrator: kubectl exec, kubectl attach, kubectl debug, or a direct call to the kubelet’s /exec and /run endpoints. The RBAC resource is the pods/exec subresource (and pods/attach, pods/ephemeralcontainers), with verb create. Controls: do not grant pods/exec broadly; audit log every exec (it is a create on a subresource and shows up with requestURI ending in /exec); runtime detection of a shell spawning inside a container that never runs shells.
T1610 Deploy Container. Creating a new container to run adversary code, typically a Pod with a chosen image, command and args, often with hostPID, hostNetwork, privileged: true or a hostPath volume to make it useful for the next step. Deploying a Pod is the Kubernetes equivalent of launching a process. Controls: Pod Security Admission at baseline or restricted so the dangerous spec fields are refused; admission policy to restrict registries; RBAC limiting who can create Pods and in which namespaces.
T1053.007 Scheduled Task/Job: Container Orchestration Job. A Kubernetes Job or CronJob. As execution it runs code once or on a schedule; as persistence it keeps re-running after the attacker’s interactive session is gone; as privilege escalation a CronJob can be created in a namespace with a more privileged ServiceAccount than the attacker’s own. Controls: RBAC on batch resources, Pod Security Admission applies to Job Pods too, audit alerts on CronJob creation outside deployment pipelines.
T1204.003 User Execution: Malicious Image. A user or pipeline pulls an image that looks legitimate but carries a backdoor: a typosquatted name on a public registry, a repository that was hijacked, or an internal image an attacker tampered with. The “user execution” is the deployment itself. Controls: pull only from trusted registries, enforce image signature verification at admission (see the CKS image signing guide), pin digests, scan in CI and at admission.
Tactic 3: Persistence
T1098.006 Account Manipulation: Additional Container Cluster Roles. The most Kubernetes-specific persistence technique: create a RoleBinding or ClusterRoleBinding that grants an attacker-controlled user or ServiceAccount additional permissions, or modify an ABAC policy where ABAC is used. A dormant ServiceAccount bound to cluster-admin survives Pod restarts, node replacement and even cluster upgrades. ATT&CK notes that on managed Kubernetes the same effect is achieved with cloud IAM role assignments. Controls: RBAC itself: the bind and escalate verbs and the rule that you cannot grant permissions you do not hold; audit alerts on any create of clusterrolebindings or bindings to cluster-admin; periodic review of who holds what.
T1136.001 Create Account: Local Account. In Kubernetes the only accounts you can create are ServiceAccounts, plus, on older clusters, a long-lived token Secret for one. A new ServiceAccount in a quiet namespace with a long-lived token is a credential that works from anywhere, forever. Controls: disable or clean up legacy ServiceAccount token Secrets (the LegacyServiceAccountTokenCleanUp behaviour), alert on ServiceAccount creation outside GitOps, inventory bindings.
T1543.005 Create or Modify System Process: Container Service. Persistence through the node-level machinery: a DaemonSet (a backdoor Pod on every node, including nodes added later), a static Pod manifest dropped into /etc/kubernetes/manifests or the kubelet’s staticPodPath (the kubelet keeps it running and it bypasses admission for creation since the kubelet, not an API client, creates it), a Pod pinned with nodeName or nodeSelector, or a tampered kubelet, containerd or Docker service with restart=always. Controls: restrict who can create DaemonSets and who has node filesystem access; file integrity monitoring on the manifests directory; NodeRestriction and kubelet hardening so a compromised node cannot broaden its reach.
T1133 External Remote Services (as persistence). Leaving yourself a way back in: an Ingress or Service exposing a reverse shell, a webhook endpoint, or a long-lived VPN account. Controls: egress and ingress network policy, review of Services of type LoadBalancer and Ingress objects.
T1525 Implant Internal Image. Pushing a backdoored image into the organisation’s own registry, or re-tagging a trusted tag to point at a malicious digest, so that every future deployment of that image carries the implant. This is supply-chain persistence and it survives everything the cluster does because it lives upstream of the cluster. Controls: registry authentication and write-access control, immutable tags, digest pinning, signing with verification at admission, provenance attestations (SLSA, covered in the compliance guide).
T1053.007 Container Orchestration Job and T1078 Valid Accounts recur here for the reasons already given: a CronJob re-establishes access on a schedule; a stolen durable credential simply keeps working.
Tactic 4: Privilege Escalation
T1611 Escape to Host. The headline container technique. ATT&CK’s own examples are: mounting the host filesystem into a container (a hostPath volume at /, which lets the attacker write to the host’s cron directory or SSH keys), running a privileged container to load a kernel module or run commands on the host, abusing system calls such as unshare and keyctl, and exploiting a mounted container runtime socket (/var/run/docker.sock or the containerd socket) to launch a privileged container from inside a container. Kernel and runtime vulnerabilities (for example the 2024 runc file-descriptor leak) add exploit-based escapes. In Pod-spec terms the enablers are privileged: true, hostPID: true plus nsenter, hostPath to sensitive paths, added capabilities such as SYS_ADMIN or SYS_MODULE, and allowPrivilegeEscalation: true. Controls: Pod Security Standards baseline blocks privileged, hostPath, host namespaces and dangerous capabilities; restricted adds non-root and allowPrivilegeEscalation: false; sandboxed runtimes (gVisor, Kata) via RuntimeClass for untrusted workloads (see the CKS sandboxing guide); user namespaces (hostUsers: false); patched kernels and runtimes. The KCSA storage security guide covers the hostPath and subPath escape family in detail.
T1068 Exploitation for Privilege Escalation. Software vulnerabilities in the kernel, the container runtime or a privileged in-cluster component that yield root or node access. Distinct from Escape to Host in that it is about the exploit, not the misconfiguration. Controls: patching, vulnerability scanning of node images, seccomp and AppArmor profiles to narrow the kernel surface.
T1098.006 Additional Container Cluster Roles, T1543.005 Container Service, T1053.007 Container Orchestration Job and T1078 Valid Accounts reappear: a binding that grants more than you had is escalation; a DaemonSet runs on every node including control-plane nodes, which is escalation; a CronJob with a more privileged ServiceAccount is escalation; a stolen admin credential is escalation. Among the Kubernetes-specific paths worth naming in an exam answer: a ServiceAccount with permission to create Pods in kube-system can mount that namespace’s privileged ServiceAccounts; one with create on pods/exec can hijack any running Pod’s identity; one with escalate or bind on RBAC resources can grant itself anything; one with create on certificatesigningrequests plus approve on the signer can mint a client certificate for any user.
Tactic 5: Stealth
T1612 Build Image on Host. Building an image inside the environment, from a Dockerfile or a build tool running in a Pod, so the malicious image never transits a registry where it would be scanned or signed. An attacker with access to a mounted runtime socket can docker build on the node directly. Controls: never mount runtime sockets into workloads, enforce signature verification so unsigned local builds cannot run, restrict hostPath.
T1070 Indicator Removal. Deleting the evidence: removing the Pods, Jobs and Events created during the intrusion, truncating container logs, clearing shell history inside a container, or deleting audit log files on a node. Kubernetes helps the attacker here by default, since Events expire after one hour and Pod logs vanish with the Pod. Controls: ship audit logs and container logs off the node in near real time to a store the cluster identity cannot delete; alert on delete of Events or of audit-related resources; retain logs centrally. The KCSA audit logging guide covers the policy and backend side.
T1036.005 Masquerading: Match Legitimate Resource Name or Location. Naming a malicious DaemonSet kube-proxy-v2, placing a backdoor Pod in kube-system, labelling it k8s-app: metrics-server, or using an image name one character away from a legitimate one. Humans scanning kubectl get pods -A do not notice. Controls: GitOps so every object in kube-system has a declared source; admission policy restricting who may create workloads in system namespaces; detection that compares running workloads to the declared desired state.
T1036.010 Masquerading: Masquerade Account Name. The same trick for identities: a ServiceAccount named cluster-autoscaler-sa or backup-operator in a namespace where no such operator exists, or a user certificate with a CN resembling an existing admin. Controls: inventory of ServiceAccounts against deployed workloads, naming conventions enforced by policy, review of new identities.
T1078 Valid Accounts (as stealth). Operating with a legitimate credential is stealth: there is no failed login, no exploit signature, just normal-looking API calls from an identity that is allowed to make them. This is why audit log analysis, which asks “is this identity doing things it normally does not do, from where it normally is not”, matters more than perimeter alerts.
Tactic 6: Defense Impairment
T1685 Disable or Modify Tools. The one technique in this column, newly numbered in v19 (it absorbed what was previously the Impair Defenses: Disable or Modify Tools sub-technique). In Kubernetes it covers: deleting or scaling down the runtime security DaemonSet (Falco or a similar agent), deleting a ValidatingWebhookConfiguration or MutatingWebhookConfiguration so a policy engine no longer sees requests, removing or relabelling Pod Security Admission labels on a namespace, editing the API server manifest to drop the audit policy or change --audit-log-path, killing the log-forwarding agent, deleting a Network Policy that blocked egress, or disabling an admission plugin. The adversary is not hiding; they are breaking your ability to see or enforce. Controls: RBAC that keeps the identities most likely to be compromised (application ServiceAccounts) away from admissionregistration.k8s.io, kube-system and node filesystems; tamper detection on the security agents themselves (an agent that stops reporting is the alert); immutable, off-cluster log and audit pipelines; GitOps drift detection so a deleted webhook is re-created and reported; policy engines configured to fail closed (failurePolicy: Fail) so that taking the webhook down denies requests rather than allowing everything.
Tactic 7: Credential Access
T1110.001, .003, .004 Brute Force: Password Guessing, Password Spraying, Credential Stuffing. The API server has no account lockout, because it has no user database; but anything in front of it or beside it that does accept passwords (a dashboard with basic auth, a registry UI, an OIDC provider, the cloud console that issues cluster credentials, an exposed etcd with password auth, SSH on nodes) is a brute-force target. Controls: MFA at the identity provider, no password-based auth to cluster components, rate limiting and lockout on the surfaces that have passwords, no SSH from the internet.
T1528 Steal Application Access Token. The quintessential Kubernetes credential theft: read /var/run/secrets/kubernetes.io/serviceaccount/token inside a compromised Pod and present it to the API server. The token is a bearer credential; whoever holds it is the ServiceAccount. Cloud metadata tokens from 169.254.169.254 are the same technique one layer down, and in some clusters are the more valuable prize. Controls: disable automount where the workload does not need the API; use bound, short-lived, audience-scoped tokens (the default since 1.24, detailed in the CKS ServiceAccount token guide); block metadata access with a default-deny egress policy (the CKS network policy guide shows the rule); on cloud nodes require the hop-limited, session-oriented metadata service version.
T1552.001 Unsecured Credentials: Credentials In Files. Passwords and keys in ConfigMaps, in environment variables visible via kubectl describe pod, in image layers, in Git history, in a kubeconfig left in a Pod’s filesystem, or in a Helm values file in a shared bucket. Controls: keep secrets in Secrets (and encrypt them at rest, see the CKS secrets encryption guide) or an external secret store; scan images and repositories for credentials; mount secrets as files rather than environment variables so they do not leak into describe output and crash dumps.
T1552.007 Unsecured Credentials: Container API. Using the orchestrator’s own API to read credentials: kubectl get secrets -A -o yaml with a ServiceAccount that has get or list on Secrets, reading Secrets through the kubelet’s /pods endpoint, reading Pod logs that contain credentials, or reading etcd directly when its client port or data directory is reachable. ATT&CK groups the Docker API’s log access under the same technique. Controls: treat list and watch on Secrets as sensitive as get (a list returns the contents); namespace-scoped Roles rather than ClusterRoles for Secret access; etcd behind mutual TLS with encryption at rest; audit alerts on bulk Secret reads.
Tactic 8: Discovery
T1613 Container and Resource Discovery. Mapping the cluster from the inside: kubectl get all -A, kubectl get nodes -o wide, kubectl auth can-i --list (which uses the SelfSubjectRulesReview API and needs no special permission), API discovery at /api and /apis, /version for the exact Kubernetes version, the kubelet’s /pods and /metrics endpoints, and on Docker hosts docker ps and docker inspect for environment variables. Controls: least-privilege RBAC so a compromised identity can see only its own namespace; disable anonymous API access so unauthenticated /version and discovery are refused; kubelet authentication and authorization; audit logging of list requests from workload identities, which are rarely legitimate at cluster scope.
T1046 Network Service Discovery. Port scanning from a compromised Pod. The flat Pod network means every Service and every Pod IP in the cluster is reachable by default, and cluster DNS helpfully enumerates Services (SRV records under cluster.local). Node ports such as 10250 and 2379 are found the same way. Controls: default-deny NetworkPolicy in every namespace, so scanning yields nothing; network observability that flags one Pod talking to hundreds of destinations; restrict DNS to what the workload needs.
T1069 Permission Groups Discovery. Learning who has what: kubectl get rolebindings,clusterrolebindings -A, kubectl describe clusterrole cluster-admin, kubectl auth can-i --list --as another identity, reading group claims out of an OIDC token. The attacker is looking for the binding that leads to escalation. Controls: restrict read access to RBAC objects (ordinary workloads never need it); audit alerts on RBAC enumeration from ServiceAccounts.
Tactic 9: Lateral Movement
T1550.001 Use Alternate Authentication Material: Application Access Token. The only lateral-movement technique in the Containers matrix, and it is the second half of Steal Application Access Token: take the ServiceAccount token (or node credential, or cloud identity token) obtained in one place and use it somewhere else. From a Pod to the API server as that ServiceAccount; from a node’s kubelet credential to the Secrets of every Pod scheduled on that node; from a cloud instance role to other clusters or cloud services; from one cluster’s credential to another cluster that trusts the same identity provider. Controls: everything that shortens and narrows tokens (bound tokens, audiences, short expiry); the Node authorizer and NodeRestriction so a node credential reaches only its own Pods’ Secrets; workload identity federation with least privilege; segmentation between clusters and environments.
Tactic 10: Impact
T1485 Data Destruction. kubectl delete namespace, deleting PersistentVolumeClaims whose PersistentVolumes have a Delete reclaim policy, wiping etcd, deleting Deployments and their ReplicaSets. Controls: RBAC with delete treated as a privileged verb; Retain reclaim policies for data that matters; etcd backups; admission policy protecting critical namespaces from deletion.
T1499 Endpoint Denial of Service. Exhausting a Pod, node or the API server: fork bombs in a container without limits, memory pressure that evicts neighbours, a flood of API requests from a compromised identity, or creating objects until etcd fills. The KCSA denial-of-service guide covers the mechanisms and controls (requests and limits, LimitRange, ResourceQuota, API Priority and Fairness, PID limits) in depth.
T1490 Inhibit System Recovery. Destroying the means of recovery before or alongside destruction: deleting etcd snapshots, VolumeSnapshots and backup Jobs, deleting the backup operator’s namespace, revoking the backup ServiceAccount’s permissions, or deleting the cloud storage bucket holding backups. ATT&CK’s examples are Windows-centric, but the Kubernetes reading is clear and ransomware against clusters follows this playbook. Controls: backups stored outside the cluster under a different identity and with immutability or object lock, tested restores, separate credentials for backup infrastructure.
T1498 Network Denial of Service. Flooding a Service or Ingress from inside or outside, or using compromised Pods as a source of volumetric traffic against others. Controls: rate limiting at the Ingress or mesh, network policy to prevent Pods from becoming traffic sources, cloud-level DDoS protection in front of load balancers.
T1496.001 Resource Hijacking: Compute Hijacking. Cryptomining, by far the most common real-world impact against Kubernetes: a Deployment or DaemonSet running a miner, often disguised (Stealth) and often with high CPU requests. T1496.002 Bandwidth Hijacking is the newer sibling: selling your egress bandwidth through proxy networks (“proxyjacking”). Controls: ResourceQuota and LimitRange so a compromised namespace cannot consume the cluster; egress network policy and DNS controls so miners cannot reach their pools; runtime detection of known miner binaries and of unexpected outbound connections; cost anomaly alerts.
The full mapping: technique, Kubernetes mechanism, control, signal
| Technique | What it looks like in Kubernetes | Primary preventive control | Detection signal |
|---|---|---|---|
| T1190 Exploit Public-Facing Application | App RCE behind Ingress; exposed API server or kubelet | Patching and scanning; no public API server; kubelet authn/authz | WAF or Ingress logs; audit: anonymous or unusual identities |
| T1133 External Remote Services | Exposed 10250, 2379, kubectl proxy, CI kubeconfig | Firewalling and NetworkPolicy; mTLS on etcd | Connections to control-plane ports from unexpected sources |
| T1078.001 Default Accounts | Automounted default SA token; vendor creds in images | automountServiceAccountToken: false; no bindings to default | Audit: system:serviceaccount:*:default making API calls |
| T1078.003 Local Accounts | Stolen kubeconfig or long-lived SA token | Short-lived bound tokens; no legacy token Secrets | Audit: identity used from a new source IP or user agent |
| T1059.013 Container CLI/API | kubectl or API driven with a stolen credential | Least-privilege RBAC | Audit log of all requests |
| T1609 Container Administration Command | kubectl exec, attach, debug; kubelet /exec | Do not grant pods/exec; kubelet authz | Audit: create on pods/exec; runtime: shell in container |
| T1610 Deploy Container | Pod with privileged, hostPath, host namespaces | Pod Security Admission baseline or restricted | Audit: Pod create with dangerous fields; PSA audit mode |
| T1053.007 Container Orchestration Job | Job or CronJob | RBAC on batch; PSA | Audit: CronJob create outside pipelines |
| T1204.003 Malicious Image | Typosquatted or hijacked image deployed | Signature verification at admission; trusted registries only | Admission denials; image provenance mismatch |
| T1098.006 Additional Container Cluster Roles | New RoleBinding or ClusterRoleBinding to attacker identity | RBAC bind/escalate rules; review | Audit: create on bindings, especially to cluster-admin |
| T1136.001 Local Account | New ServiceAccount plus long-lived token | Clean up legacy token Secrets; GitOps | Audit: ServiceAccount or token Secret create |
| T1543.005 Container Service | DaemonSet; static Pod manifest; tampered kubelet | RBAC on DaemonSets; node FS access; file integrity | Static Pod appears without API create; DaemonSet create |
| T1525 Implant Internal Image | Backdoored image pushed to own registry; retagged tag | Registry write control; immutable tags; signing | Registry push by unexpected identity; digest change |
| T1611 Escape to Host | privileged, hostPath /, hostPID + nsenter, runtime socket | PSS baseline/restricted; sandboxed RuntimeClass; user namespaces | Runtime: container process touching host paths or loading modules |
| T1068 Exploitation for Privilege Escalation | Kernel or runtime CVE | Patching; seccomp/AppArmor | Runtime: unexpected syscalls; crash signatures |
| T1612 Build Image on Host | In-cluster build via mounted runtime socket | No socket mounts; signature verification | Runtime: build tooling executing in a Pod |
| T1070 Indicator Removal | Delete Pods, Events, logs; truncate audit files | Off-node log shipping; retention | Audit: delete on Events; agent gaps |
| T1036.005 Match Legitimate Resource Name | kube-proxy-v2 DaemonSet in kube-system | GitOps and admission on system namespaces | Drift between desired and running state |
| T1036.010 Masquerade Account Name | SA named like a known operator | Identity inventory; naming policy | New SA without matching workload |
| T1685 Disable or Modify Tools | Delete Falco DaemonSet, webhook config, audit policy | RBAC away from admissionregistration and kube-system; fail-closed webhooks | Agent heartbeat loss; audit: webhook config delete |
| T1110.x Brute Force | Passwords at dashboard, IdP, SSH, registry | MFA; no password auth to components; lockout | IdP and SSH auth failure spikes |
| T1528 Steal Application Access Token | Read SA token in Pod; metadata token | Automount off; bound short tokens; block metadata egress | Audit: token used from unexpected Pod or IP |
| T1552.001 Credentials In Files | Secrets in ConfigMaps, env vars, images, Git | Secrets objects with encryption; scanning | Scanner findings; describe pod exposure |
| T1552.007 Container API | get/list Secrets; kubelet /pods; etcd read | Namespace-scoped Secret RBAC; etcd mTLS and encryption | Audit: bulk Secret list by workload identity |
| T1613 Container and Resource Discovery | get all -A, auth can-i --list, /version, discovery | Least privilege; no anonymous access | Audit: cluster-wide list from a ServiceAccount |
| T1046 Network Service Discovery | Port scan from a Pod; DNS SRV enumeration | Default-deny NetworkPolicy | Flow logs: one Pod to many destinations |
| T1069 Permission Groups Discovery | get rolebindings -A; auth can-i --as | Restrict read on RBAC objects | Audit: RBAC enumeration by workloads |
| T1550.001 Application Access Token | Stolen token used elsewhere | Bound tokens; Node authorizer and NodeRestriction | Audit: same token from multiple sources |
| T1485 Data Destruction | Delete namespaces, PVCs, etcd | delete as privileged verb; Retain; backups | Audit: mass deletes |
| T1499 Endpoint Denial of Service | Resource exhaustion; API flooding | Requests/limits; quotas; API Priority and Fairness | Eviction and 429 spikes |
| T1490 Inhibit System Recovery | Delete snapshots, backups, backup operator | Off-cluster immutable backups | Backup Job failures; snapshot deletes |
| T1498 Network Denial of Service | Traffic floods to or from Pods | Rate limiting; egress policy; DDoS protection | Ingress and flow telemetry |
| T1496.001 / .002 Compute and Bandwidth Hijacking | Miners; proxyjacking Pods | Quotas; egress policy; runtime detection | CPU anomalies; outbound to mining pools |
Mapping the matrix to the six KCSA attacker goals and STRIDE
The KCSA threat-model domain names six attacker goals rather than ten tactics. The two views line up cleanly, which is useful because an exam question may describe a behaviour using either vocabulary.
| KCSA attacker goal | ATT&CK tactics it spans | Techniques that embody it | STRIDE category |
|---|---|---|---|
| Persistence | Persistence | Additional Container Cluster Roles; Local Account; Container Service; Implant Internal Image; Container Orchestration Job | Elevation of Privilege, Tampering |
| Privilege Escalation | Privilege Escalation | Escape to Host; Exploitation for Privilege Escalation; Additional Container Cluster Roles | Elevation of Privilege |
| Denial of Service and Lateral Movement | Impact; Lateral Movement; Discovery | Endpoint and Network DoS; Resource Hijacking; Application Access Token; Network Service Discovery | Denial of Service, Spoofing |
| Malicious Code and Compromised Applications in Containers | Initial Access; Execution; Stealth | Exploit Public-Facing Application; Malicious Image; Deploy Container; Build Image on Host | Tampering |
| Access to Sensitive Data | Credential Access; Discovery | Steal Application Access Token; Unsecured Credentials (Files, Container API); Container and Resource Discovery | Information Disclosure |
| Attacker on the Network | Initial Access; Credential Access; Lateral Movement | External Remote Services; Brute Force; Application Access Token | Spoofing, Information Disclosure, Tampering |
Two observations the exam rewards. First, Stealth and Defense Impairment have no direct KCSA goal: they are supporting tactics an attacker uses while pursuing one of the six. If a scenario describes deleting audit logs, the goal is whatever the attacker was hiding; the tactic is Stealth or Defense Impairment. Second, STRIDE’s Repudiation maps to Indicator Removal and to disabling audit logging: an attacker who can delete the record can deny the act, which is exactly why audit logs must be shipped somewhere the cluster identity cannot reach.
How the KCSA asks about ATT&CK
The question styles cluster into five shapes:
| Cue in the question | What it is asking | Answer pattern |
|---|---|---|
| ”Which framework catalogues real-world adversary tactics and techniques against containers?” | Identify ATT&CK | MITRE ATT&CK (Containers matrix); contrast with CIS (hardening baseline), NIST SP 800-190 (control guidance), STRIDE (threat-modelling method) |
“An attacker runs kubectl get secrets -A from a compromised Pod. Which tactic?” | Classify a behaviour | Credential Access (Unsecured Credentials: Container API); the preceding auth can-i --list would be Discovery |
| ”Which technique describes a privileged container used to access the node?” | Name a technique | Escape to Host (T1611), Privilege Escalation tactic |
| ”Which control mitigates Deploy Container with hostPath mounts?” | Map technique to control | Pod Security Admission enforcing baseline or stricter |
| ”An attacker deletes the Falco DaemonSet. Stealth or Defense Impairment?” | Apply the v19 split | Defense Impairment: the defence is broken, not evaded |
”An attacker names a backdoor DaemonSet kube-proxy-v2. Which tactic?” | Apply the v19 split | Stealth: Masquerading, defences left intact |
| ”What distinguishes a threat model from ATT&CK?” | Conceptual contrast | A threat model is your analysis of your system’s trust boundaries and threats; ATT&CK is a shared catalogue of observed adversary behaviour you map that analysis against |
Using the matrix as a working tool
The KCSA is conceptual, but the reason ATT&CK is in the curriculum is that practitioners use it for three concrete jobs, and understanding those jobs makes the conceptual questions obvious.
Coverage mapping. Take the 36 technique cells of the Containers matrix and colour each one by whether you have a preventive control, a detection, both or neither. ATT&CK Navigator, MITRE’s free layer tool, exists for exactly this. A typical first pass on a cluster with Pod Security Admission, default-deny NetworkPolicy and audit logging shipped off-cluster covers most of Execution, Privilege Escalation, Discovery and Lateral Movement, and leaves gaps in Persistence (nobody reviews bindings), Stealth (no drift detection) and Impact (backups untested). The gaps are your roadmap.
Detection engineering. Each technique page’s detection strategies and analytics describe what to look for. For Kubernetes most of them resolve to audit log analytics (binding creates, exec creates, Secret lists, webhook deletes, mass deletes) plus runtime signals (shell spawned in a container, container process reading /etc/shadow on the host, outbound connection to a mining pool). The CKS runtime security guide shows how Falco rules express the runtime half; the audit logging guide covers the policy that makes the API half possible.
Incident narration. When something does happen, describing it in ATT&CK terms (“Initial Access via Exploit Public-Facing Application, Credential Access via Steal Application Access Token, Discovery via Container and Resource Discovery, Privilege Escalation via Additional Container Cluster Roles, Impact via Compute Hijacking”) gives responders, management and auditors a shared vocabulary and lets you compare incidents across time and teams. The compliance guide’s point about frameworks fitting together applies here: CIS tells you how to harden, ATT&CK tells you what the hardening is for, and the gaps between them tell you what to monitor.
ATT&CK mitigations also map neatly onto Kubernetes controls, which is handy for exam options written in ATT&CK language: M1047 Audit is audit logging and RBAC review; M1026 Privileged Account Management is least-privilege RBAC and no cluster-admin for workloads; M1018 User Account Management is ServiceAccount hygiene; M1030 Network Segmentation and M1037 Filter Network Traffic are NetworkPolicy; M1038 Execution Prevention and M1045 Code Signing are admission control and image signature verification; M1048 Application Isolation and Sandboxing is Pod Security Standards plus sandboxed runtimes; M1053 Data Backup is etcd and volume backups stored off-cluster.
Common KCSA traps in this topic
- Treating ATT&CK as a compliance framework. It is not a standard you comply with; it is a knowledge base of adversary behaviour you measure your controls against. CIS and NIST are the compliance-shaped frameworks.
- Confusing ATT&CK with a threat model. STRIDE is a method for building a threat model; ATT&CK is data about real attackers you validate the model against.
- Still answering “Defense Evasion”. Since v19 the Containers matrix has Stealth (hiding) and Defense Impairment (breaking defences). Know both and the line between them.
- Assuming every Enterprise tactic has container techniques. Reconnaissance, Resource Development, Collection, Command and Control and Exfiltration have none in the Containers matrix.
- Thinking Escape to Host is only about
privileged: true. hostPath to sensitive paths, host namespaces, runtime socket mounts and kernel exploits are all listed under the same technique. - Forgetting that Valid Accounts is in four tactics. A stolen credential is access, persistence, escalation and stealth at once, which is the strongest argument for short-lived tokens.
- Treating
liston Secrets as harmless because it “only lists”. Alistreturns full Secret contents and is the canonical Container API credential-access call. - Believing deleting a Pod removes the evidence of what it did. Only if audit logs stay on the cluster. Off-cluster shipping is the control against Indicator Removal.
Scenario drill
| Scenario | Tactic | Technique | Primary control |
|---|---|---|---|
| A web app with an SSRF bug is used to reach the API server from inside a Pod | Initial Access | Exploit Public-Facing Application (T1190) | Patching; network policy; no anonymous API access |
| Attacker finds port 10250 open with anonymous auth and lists Pods via the kubelet | Initial Access / Discovery | External Remote Services (T1133); Container and Resource Discovery (T1613) | Kubelet anonymous.enabled: false, authorization.mode: Webhook; firewalling |
Attacker reads /var/run/secrets/kubernetes.io/serviceaccount/token in a compromised Pod | Credential Access | Steal Application Access Token (T1528) | automountServiceAccountToken: false; bound short-lived tokens |
| Attacker uses that token from their laptop to call the API server | Lateral Movement | Application Access Token (T1550.001) | Audience-bound tokens; short expiry; audit of source IPs |
Attacker runs kubectl auth can-i --list and kubectl get rolebindings -A | Discovery | Container and Resource Discovery (T1613); Permission Groups Discovery (T1069) | Least-privilege RBAC; audit alerts on enumeration |
Attacker runs kubectl get secrets -A -o yaml | Credential Access | Unsecured Credentials: Container API (T1552.007) | Namespace-scoped Secret RBAC; no list on Secrets for workloads |
Attacker creates a ClusterRoleBinding granting their ServiceAccount cluster-admin | Persistence / Privilege Escalation | Additional Container Cluster Roles (T1098.006) | RBAC bind/escalate restrictions; binding-create alerts |
| Attacker creates a new ServiceAccount and a long-lived token Secret for it | Persistence | Local Account (T1136.001) | Legacy token clean-up; GitOps-only identity creation |
Attacker deploys a Pod with privileged: true and hostPath: / then edits the node’s cron | Execution / Privilege Escalation | Deploy Container (T1610); Escape to Host (T1611) | Pod Security Admission baseline or restricted |
Attacker runs kubectl exec into a payment Pod | Execution | Container Administration Command (T1609) | Do not grant pods/exec; audit and runtime detection |
| Attacker creates a CronJob that re-opens a reverse shell hourly | Persistence / Execution | Container Orchestration Job (T1053.007) | RBAC on batch; egress NetworkPolicy; CronJob alerts |
Attacker deploys a DaemonSet named kube-proxy-v2 in kube-system | Persistence / Stealth | Container Service (T1543.005); Match Legitimate Resource Name (T1036.005) | Restrict DaemonSet creation; GitOps drift detection |
Attacker drops a Pod manifest into /etc/kubernetes/manifests on a node | Persistence | Container Service (T1543.005) | Node filesystem access control; file integrity monitoring |
| Attacker pushes a backdoored tag of the company’s base image to the internal registry | Persistence | Implant Internal Image (T1525) | Registry write control; immutable tags; signature verification |
| Attacker builds an image inside a Pod using a mounted containerd socket | Stealth | Build Image on Host (T1612) | Never mount runtime sockets; verify signatures at admission |
| Attacker deletes their Pods and the namespace Events | Stealth | Indicator Removal (T1070) | Off-cluster audit and log shipping |
| Attacker scales the Falco DaemonSet to zero | Defense Impairment | Disable or Modify Tools (T1685) | RBAC; agent heartbeat alerting |
| Attacker deletes the policy engine’s ValidatingWebhookConfiguration | Defense Impairment | Disable or Modify Tools (T1685) | RBAC on admissionregistration.k8s.io; drift detection; fail-closed policy |
| Attacker uses a stolen cloud credential to disable the cluster’s backup bucket versioning, then deletes PVCs | Impact | Inhibit System Recovery (T1490); Data Destruction (T1485) | Immutable off-cluster backups under separate identity; Retain policies |
| A Deployment appears running a cryptominer with high CPU requests | Impact | Compute Hijacking (T1496.001) | ResourceQuota; egress policy; runtime detection |
| Pods are used to relay traffic for a residential proxy network | Impact | Bandwidth Hijacking (T1496.002) | Egress NetworkPolicy; flow monitoring |
| An image pulled from a public registry has a name one letter off the official one | Execution | Malicious Image (T1204.003) | Trusted registries only; signature verification; digest pinning |
| Attacker port-scans the Pod network and enumerates Services via DNS | Discovery | Network Service Discovery (T1046) | Default-deny NetworkPolicy |
| Attacker floods the API server with list requests from a compromised identity | Impact | Endpoint Denial of Service (T1499) | API Priority and Fairness; RBAC; rate limiting |
Frequently Asked Questions
Is the Containers matrix a Kubernetes matrix?
ATT&CK has no Kubernetes-specific matrix. Containers is a platform within Enterprise ATT&CK, and its matrix contains every technique tagged with that platform, which covers Kubernetes, Docker and other container runtimes together. Technique descriptions call out Kubernetes specifics (kubectl exec, DaemonSets, RoleBindings, ServiceAccount tokens) where they apply.
What changed in ATT&CK v19 and v20 that affects the Containers matrix?
v19 (April 2026) split the Defense Evasion tactic into Stealth (TA0005, concealment that leaves defences intact) and Defense Impairment (TA0112, directly degrading defences), and renumbered the “Disable or Modify Tools” behaviour as its own technique, T1685. The Containers matrix therefore has ten columns. v20 (13 October 2026, current as v20.1) expanded coverage of recent adversary activity across ATT&CK; the Containers matrix in v20.1 lists the techniques walked through in this article.
How much of the KCSA is about MITRE ATT&CK?
ATT&CK sits inside two domains: Compliance and Security Frameworks (10%), as a threat-modelling framework alongside STRIDE, and indirectly Kubernetes Threat Model (16%), whose six attacker goals correspond to ATT&CK tactics. Expect a handful of questions that ask you to identify the framework, classify a behaviour into a tactic, or match a technique to a control. You do not need to memorise technique IDs, but knowing the names and which column they belong to makes those questions fast.
What is the difference between ATT&CK, STRIDE and a threat model?
A threat model is your own analysis of your own system: its trust boundaries, data flows and what could go wrong at each. STRIDE is a method for building one, prompting you to consider Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service and Elevation of Privilege at each boundary. ATT&CK is a catalogue of what real adversaries have actually done, which you use to check whether your model and your controls cover reality.
Which single ATT&CK technique matters most for Kubernetes?
If you had to pick one, Escape to Host (T1611), because it turns a compromised container into a compromised node and every Pod on it, and because the controls against it (Pod Security Standards, sandboxed runtimes, no runtime socket mounts) are the ones the KCSA tests most heavily. A close second is Steal Application Access Token (T1528), because the ServiceAccount token is the credential that connects a compromised Pod to the API server.
Does Kubernetes have built-in protection against these techniques?
For many of them, yes, but off by default or needing configuration: Pod Security Admission (Deploy Container, Escape to Host), RBAC (Additional Container Cluster Roles, Container API, Discovery), NetworkPolicy (Network Service Discovery, Steal Application Access Token via metadata, Resource Hijacking egress), bound ServiceAccount tokens (Application Access Token), audit logging (detection of nearly everything), NodeRestriction (Lateral Movement from a node), encryption at rest (Container API against etcd). Supply-chain techniques (Malicious Image, Implant Internal Image) and Defense Impairment need controls outside the core: signing and verification, registry controls, off-cluster logging and tamper-evident agents.
Where should I study ATT&CK itself?
The matrix and every technique page are free on MITRE’s site, and ATT&CK Navigator lets you build coverage layers. For the KCSA you need the Containers matrix, the ten tactic definitions and the technique descriptions; the group, software and campaign pages are background.
Conclusion
The Containers matrix is small enough to learn completely: ten tactics and a few dozen techniques, every one of which corresponds to a specific Kubernetes API call, Pod spec field or node-level action, and every one of which has a known control. Initial Access is an exploited app or an exposed component; Execution is exec, a new Pod or a Job; Persistence is a binding, a ServiceAccount, a DaemonSet or a poisoned image; Privilege Escalation is Escape to Host or a binding that grants more; Stealth is blending in and tidying up; Defense Impairment is switching the cameras off; Credential Access is the ServiceAccount token and anything in Secrets; Discovery is auth can-i --list and a port scan; Lateral Movement is using that token elsewhere; Impact is deletion, exhaustion, destroying backups and mining. Read in that order the matrix is simply the story of a Kubernetes intrusion, and the controls read back are the KCSA syllabus.
If you want to confirm the classifications are automatic under time pressure, Sailor.sh’s KCSA Certification-Ready Mock Exam Bundle presents threat-model and framework scenarios in the exam’s own phrasing across five timed mock exams with explanations, so a misclassified tactic or a confused Stealth-versus-Defense-Impairment answer becomes a fixed mental model before it costs you a mark. Pair it with the KCSA exam guide for the study plan and the free KCSA practice questions for a quick check.
Continue with the KCSA threat model guide for the six attacker goals in the curriculum’s own words, the compliance and security frameworks guide for how ATT&CK sits beside CIS, NIST and SLSA, the Pod Security Standards guide for the control behind Deploy Container and Escape to Host, and the KCSA platform security guide for the supply-chain techniques’ defensive side.