KCSA Compliance Frameworks, Threat Modeling and Supply Chain Compliance
Compliance and security frameworks for Kubernetes are the published benchmarks, threat models and supply chain standards that define a secure cluster, describe how it is attacked, and let a team prove it meets an agreed baseline. This lesson covers the CIS Kubernetes Benchmark and kube-bench, the NSA/CISA Kubernetes Hardening Guidance, NIST SP 800-190 and the Cybersecurity Framework 2.0, how regulations such as PCI DSS apply and how segmentation reduces scope, continuous compliance and drift, threat modeling with data flow diagrams, STRIDE and MITRE ATT&CK, the SLSA Build track, in-toto, VEX and OpenSSF Scorecard, and the tools that automate the checks: Kubescape, Trivy, Gatekeeper audit and Kyverno policy reports.
On this page10 sections
- What compliance and security frameworks do for a Kubernetes cluster
- The CIS Kubernetes Benchmark and kube-bench
- Government guidance: NSA/CISA Hardening Guidance and NIST
- Regulations, assessment scope and continuous compliance
- Threat modeling: the process, data flow diagrams and trust boundaries
- STRIDE: six threat categories and the Kubernetes controls for each
- MITRE ATT&CK for containers and the Kubernetes threat matrix
- Supply chain compliance: SLSA Build levels and in-toto
- VEX statements and OpenSSF Scorecard
- Automation and tooling: scanners and policy engine reports
- Explain the CIS Kubernetes Benchmark's Level 1 and Level 2 profiles, Automated and Manual checks, and when to use a provider-specific benchmark
- Describe how kube-bench runs on a node and interpret PASS, FAIL, WARN and INFO results
- Compare the NSA/CISA Hardening Guidance, NIST SP 800-190 and NIST CSF 2.0, and map Kubernetes controls to CSF functions
- Explain how regulations such as PCI DSS apply to Kubernetes, why segmentation reduces scope, and why compliance must be checked continuously
- Build a threat model from a data flow diagram with trust boundaries, classify threats with STRIDE and map attacks to MITRE ATT&CK tactics and techniques
- Place a build setup on the SLSA Build track and explain in-toto layouts, VEX statements and OpenSSF Scorecard
- Choose between kube-bench, Kubescape, Trivy, Gatekeeper audit and Kyverno policy reports for a given compliance need
What compliance and security frameworks do for a Kubernetes cluster
Compliance and security frameworks are published reference documents that tell a team what a secure cluster looks like, what can go wrong, and how to prove the cluster meets an agreed standard. Kubernetes ships with many permissive defaults and hundreds of settings, so teams lean on frameworks rather than invent their own baseline.
The frameworks in this topic fall into four families, and the first skill is knowing which family answers which question:
| Family | Question it answers | Examples |
|---|---|---|
| Compliance and hardening frameworks | What settings and practices should the cluster have, and does it have them? | CIS Kubernetes Benchmark, NSA/CISA Kubernetes Hardening Guidance, NIST SP 800-190, NIST CSF 2.0, regulations such as PCI DSS, HIPAA and GDPR |
| Threat modeling frameworks | What could an attacker do to this design, and how do real attacks unfold? | STRIDE, MITRE ATT&CK Containers matrix, Microsoft's Threat Matrix for Kubernetes |
| Supply chain frameworks | Can we trust how our software was built and what it depends on? | SLSA, in-toto, VEX, OpenSSF Scorecard |
| Automation and tooling | How do we check all of this repeatedly without doing it by hand? | kube-bench, Kubescape, Trivy, OPA Gatekeeper audit, Kyverno policy reports |
A useful way to keep them apart: hardening frameworks describe the desired state, threat models describe the attacker, supply chain frameworks describe the path code takes into the cluster, and tools produce the evidence. Admission control mechanics, SBOMs, image signing and runtime detection are taught in the KCSA lessons on supply chain and admission control and on observability; this lesson covers the frameworks themselves and the tools that check a cluster against them.
The CIS Kubernetes Benchmark and kube-bench
The CIS Kubernetes Benchmark is a consensus document from the Center for Internet Security that lists numbered hardening recommendations for Kubernetes components, each with a rationale, an audit procedure and a remediation. Its sections cover the control plane components (API server, controller manager, scheduler), etcd, control plane configuration such as authentication and logging, the worker nodes (kubelet and its configuration files) and policies such as RBAC, Pod Security and NetworkPolicy.
Every recommendation carries two independent tags:
| Tag | Values | What it means |
|---|---|---|
| Profile | Level 1 / Level 2 | Level 1 is a practical, prudent baseline that should have little impact on how the cluster is used. Level 2 is defence in depth for environments where security is paramount, and some items may reduce functionality or need more effort. |
| Assessment status | Automated / Manual | Automated items can be checked by a tool from the system's configuration. Manual items need a person to judge them, for example whether RBAC grants are minimal. |
The two tags are often confused. Level is about how strict and how disruptive the recommendation is; Automated or Manual is about how it can be checked. The two tags are independent of each other and of the component a check belongs to.
Managed Kubernetes needs its own benchmark
On a managed service such as Amazon EKS, Azure AKS or Google GKE, the provider runs the control plane and etcd. The customer cannot read API server flags or etcd data files, so the generic benchmark's control plane checks cannot be performed and are not the customer's to fix. CIS therefore publishes provider-specific benchmarks (for EKS, AKS, GKE and others) that cover the parts the customer controls: worker nodes, policies and the managed-service configuration. Assessing a managed cluster against the generic benchmark, or reporting every unreachable control plane item as a failure, misreads the shared responsibility split.
Running kube-bench and reading its results
kube-bench is an open-source tool from Aqua Security that runs the CIS Kubernetes Benchmark checks on a node and reports each one as PASS, FAIL, WARN or INFO. It picks the benchmark version to match the Kubernetes version or platform, and it supports provider benchmarks such as EKS, AKS and GKE.
Why it has to run on the host
Many CIS checks look at things that are not in the Kubernetes API at all: the ownership and permissions of configuration files, and the command-line arguments of the running kubelet or API server process. A tool that only talks to the API server cannot see them, and neither can an admission controller, which only sees API requests. kube-bench is therefore run either as a binary directly on the node or, more commonly, as a Kubernetes Job scheduled onto the node with:
hostPID: true, so it can see the host's processes and read their arguments;- read-only
hostPathmounts of directories such as/etc/kubernetesand/var/lib/kubelet, so it can inspect the files.
The project ships separate job manifests for control plane and worker nodes and for the managed services.
What each result means
| Result | Meaning |
|---|---|
| PASS | The automated check found the recommended setting. |
| FAIL | The automated check found a non-compliant setting; remediation text says how to fix it. |
| WARN | The check could not be decided automatically, usually because the benchmark marks it Manual. A person must verify it, using the remediation text as a guide. |
| INFO | Informational output, not a judgement. |
A run with zero FAIL results is therefore not the end of the job: WARN items still need human review. kube-bench can write JSON output, which is what teams ship to central storage when they need a history of results.
Government guidance: NSA/CISA Hardening Guidance and NIST
The main government guidance for Kubernetes security is the NSA/CISA Kubernetes Hardening Guidance, supported by NIST SP 800-190 for container risks and the NIST Cybersecurity Framework 2.0 for mapping controls to security outcomes. None of them is a pass/fail checklist like the CIS Benchmark, but scanners can assess clusters against controls derived from them.
The Kubernetes Hardening Guidance is a joint publication of the US National Security Agency (NSA) and the Cybersecurity and Infrastructure Security Agency (CISA) that explains how Kubernetes is attacked and recommends practices to reduce the risk. The current version is 1.2 (2022). Its recommendations include scanning images and containers, running containers and Pods with the least privilege needed, network separation and NetworkPolicy, strong authentication and RBAC, audit logging and threat detection, and keeping components upgraded and reviewed.
The guidance and the CIS Benchmark are complementary, not competing:
| NSA/CISA Hardening Guidance | CIS Kubernetes Benchmark | |
|---|---|---|
| Author | Two US government agencies | Center for Internet Security community consensus |
| Style | Threat-led narrative: why each practice matters | Numbered recommendations with audit and remediation steps |
| Pass/fail checklist? | No | Yes, which is why tools audit against it |
| Scope | Whole cluster and workloads, including practices | Component configuration plus policies, per Kubernetes version or provider |
Both are voluntary guidance that apply to any cluster. Tools turn the NSA/CISA guidance into checkable controls: Kubescape has an NSA framework, and Trivy has a built-in NSA compliance specification.
NIST guidance: SP 800-190 and the Cybersecurity Framework 2.0
NIST SP 800-190, the Application Container Security Guide, is the NIST publication on container risks; it groups them into five areas: image, registry, orchestrator, container and host operating system risks. For each area it recommends countermeasures that map naturally onto Kubernetes: scanning images and keeping them minimal, securing and authenticating registry access, restricting orchestrator administrative access with RBAC and separating workloads of different sensitivity, limiting container runtime privileges, and using a minimal, hardened host OS. Other NIST publications are often confused with it: SP 800-53 Rev. 5 is the general catalogue of security and privacy controls, SP 800-63 covers digital identity, and SP 800-61 covers incident handling.
The Cybersecurity Framework 2.0 functions
The NIST Cybersecurity Framework (CSF) 2.0, published in 2024, organises security outcomes into six functions. Mapping Kubernetes controls to them shows coverage and gaps:
| Function | Outcome | Kubernetes examples |
|---|---|---|
| Govern | Risk strategy, roles, policy, oversight, and cybersecurity supply chain risk management | Owning supplier risk for base images and Helm charts, contract requirements, cluster security policy |
| Identify | Understanding assets and risks | Inventory of clusters, workloads and SBOMs; risk assessment |
| Protect | Safeguards | RBAC, Pod Security admission, NetworkPolicy, encryption of Secrets |
| Detect | Finding events and anomalies | Alerts on unexpected outbound connections from a workload, audit log monitoring |
| Respond | Acting on a detected incident | Isolating or deleting a compromised Pod, revoking credentials |
| Recover | Restoring normal operations | Restoring etcd from backup, redeploying from trusted images |
Govern is new in CSF 2.0. It took in the supply chain risk management category (GV.SC), which in CSF 1.1 sat under Identify. Work such as assigning ownership of supplier risk and writing security requirements into vendor contracts is therefore Govern in the current version.
Regulations, assessment scope and continuous compliance
Regulations decide what must be protected and who is assessed, and continuous compliance is how a team keeps proving it after the first assessment.
Regulations and industry standards such as PCI DSS, HIPAA and GDPR state outcomes a system must achieve, such as protecting personal or cardholder data, controlling access and keeping accountability, rather than specific Kubernetes settings. They are technology-neutral: none lists API server flags, approved images or a required Pod Security Standard. A team meets them by choosing controls (encryption, RBAC, audit logging, segmentation, vulnerability management) and mapping each control to a requirement, often using a benchmark such as CIS as evidence of hardening.
PCI DSS scope on Kubernetes
Under PCI DSS, the assessment scope is the cardholder data environment: the system components that store, process or transmit cardholder data, plus every component connected to them or able to affect their security. On a shared cluster, the nodes, the network, the control plane and cluster services can all affect the payment workloads, so the assessor may treat the whole cluster as in scope.
The lever that shrinks scope is segmentation: running the payment workloads in a dedicated cluster with its own network boundary, or on dedicated nodes with enforced network isolation, so that unrelated systems can no longer affect them. Scope follows connectivity, so only isolation shrinks it: a control that makes a connected system more secure leaves it connected, and therefore still in scope. Fully isolated systems that cannot affect the cardholder data environment are out of scope.
Compliance is continuous: drift, scheduled checks and evidence over time
A compliance report is point-in-time evidence: it proves the state of the cluster only at the moment the check ran. After that, the cluster keeps changing. New nodes join, upgrades rewrite configuration, and engineers edit settings by hand. When live settings move away from the state that was assessed, that is configuration drift. (A deliberate, approved deviation recorded with its justification is a documented exception, which is different.)
Continuous compliance closes the gap:
- Run checks on a schedule, on every node, not once. A check that runs a single time per node, however thorough, says nothing about changes made to that node afterwards.
- Alert on new failures, so drift is fixed in days rather than found at the next audit.
- Keep the timestamped results of every run in central storage (for example kube-bench JSON output). Evidence about a period needs records retained from that period: anything that describes only today's state cannot show what the settings were months ago.
Choose the checking mechanism by where the setting lives. Kubelet and control plane configuration lives on the host as files and process flags, so only host-level checks such as kube-bench see it; anything that works through the Kubernetes API sees only API objects and API requests. Settings that are API objects, such as Pod specs, are what policy engine audits cover (see the last section).
Threat modeling: the process, data flow diagrams and trust boundaries
Threat modeling is a structured way to find what can go wrong with a system's design and decide what to do about it, ideally before the system is built. It is commonly framed as four questions: what are we working on, what can go wrong, what are we going to do about it, and did we do a good enough job?
The usual starting point is a data flow diagram (DFD) of the system: external entities (users, the internet, external services), processes (Ingress controller, application Pods, the API server), data stores (etcd, databases) and the flows between them. On it the team draws trust boundaries: lines wherever a flow crosses between components with different levels of trust or privilege, such as from the internet into the Ingress controller, from a workload to the API server, or from the cluster out to a third party. Boundary crossings are where spoofing, tampering and escalation happen, so threats are listed at each one. What defines a trust boundary is a change in trust or privilege between its two sides; where components run, who owns them and how traffic is filtered are separate properties that may or may not line up with it.
Threat modeling gives most value during design, when changes are cheap, and it must be revisited when the design changes. A new flow, such as a webhook that lets a third-party provider call into the cluster, creates a new trust boundary the original model never assessed: update the DFD and assess the threats at that crossing (who is calling, how the caller is authenticated, what the flow can reach, what happens if the other side is compromised). Testing examines a system that already exists; it does not replace reviewing the design. The specific trust boundaries inside a cluster are taught in the KCSA lesson on trust boundaries, persistence and denial of service.
STRIDE: six threat categories and the Kubernetes controls for each
STRIDE is a threat classification method that sorts threats into six categories, each the violation of one security property: Spoofing, Tampering, Repudiation, Information disclosure, Denial of service and Elevation of privilege. Applied to each element and boundary crossing of a data flow diagram, it gives a checklist of what to look for.
| Category | Property violated | Kubernetes example | Typical controls |
|---|---|---|---|
| Spoofing | Authentication | Using a stolen ServiceAccount token or client certificate to act as someone else | Strong authentication, short-lived tokens, certificate management |
| Tampering | Integrity | Altering a request in transit, or changing an image or a stored object | TLS on every connection to the API server, image signing, RBAC on writes |
| Repudiation | Non-repudiation (accountability) | An operator scales a production StatefulSet to zero and later denies it, and no record shows which identity sent the request | API server audit policy, audit logs shipped off the control plane |
| Information disclosure | Confidentiality | Reading Secrets from etcd backups or over an unencrypted connection | Encryption at rest for Secrets, TLS, least-privilege RBAC on reads |
| Denial of service | Availability | A Pod with no limits consuming a node's memory so neighbours are evicted | Resource limits, LimitRange, ResourceQuota, API Priority and Fairness |
| Elevation of privilege | Authorization | A developer who may only edit Deployments adds hostPID: true and a privileged container to a Pod template, then acts as root on the node | Pod Security admission (baseline forbids privileged containers, host namespaces and hostPath volumes), least-privilege RBAC |
Two habits help when classifying. First, name the threat itself, not one of its possible consequences: turning limited API rights into root on a node is elevation of privilege, even though an attacker could then tamper with things. Second, match the control to where the threat happens. A request altered in transit is stopped by TLS, because RBAC and audit logging only act once the request has reached the API server and cannot tell an altered request from a genuine one. An escalation that runs through the Pod spec is stopped where Pod specs are checked, at admission.
MITRE ATT&CK for containers and the Kubernetes threat matrix
MITRE ATT&CK is a public knowledge base of real adversary behaviour, organised as a matrix of tactics (the attacker's goal at a stage) and techniques (how the attacker achieves that goal). The Containers matrix applies it to container and orchestration environments, and Microsoft's Threat Matrix for Kubernetes was modelled on the same structure. Mitigations and software are separate ATT&CK objects linked to techniques; CVEs are not the unit of the model.
Tactics in the Containers matrix include Initial Access, Execution, Persistence, Privilege Escalation, Defense Evasion, Credential Access, Discovery, Lateral Movement and Impact. Mapping an incident to them means asking what the attacker was trying to achieve at each step:
| Observed action | Tactic (goal) | Technique (how) |
|---|---|---|
| Exploiting a vulnerable public web application in a Pod | Initial Access | Exploit Public-Facing Application |
| Starting a new container to run attacker code | Execution (also Defense Evasion) | Deploy Container |
| Pushing a backdoored image into the internal registry, or creating a scheduled job, so access survives restarts | Persistence | Implant Internal Image; Scheduled Task/Job |
| Reading a cloud access key left in a mounted configuration file | Credential Access | Unsecured Credentials |
| Using a privileged container or host mount to reach the node | Privilege Escalation | Escape to Host |
| Running cryptocurrency miners on the victim's compute | Impact | Resource Hijacking |
The same incident usually spans several tactics: the exploit is Initial Access, collecting credentials is Credential Access, and using their rights to reach the node would be Privilege Escalation. Mitigations attach to techniques, for example setting automountServiceAccountToken: false where a Pod does not need the API and keeping its RBAC minimal. STRIDE helps reason about a design you are building; ATT&CK describes how attackers actually behave and is used for detection coverage, incident analysis and testing.
Supply chain compliance: SLSA Build levels and in-toto
SLSA (Supply-chain Levels for Software Artifacts) is an OpenSSF framework that defines graded levels of assurance that an artifact was built the way its provenance claims. In SLSA 1.x the Build track has levels 0 to 3, and each level adds requirements to the one below. SLSA v0.1 had a Level 4; the 1.x Build track ends at Level 3.
| Build level | Requirement | What it protects against |
|---|---|---|
| L0 | No guarantees | Nothing |
| L1 | Provenance exists, describing how the artifact was built (it need not be signed) | Mistakes; gives visibility into the build |
| L2 | A hosted build platform generates and signs the provenance | Tampering after the build; forged provenance from a developer laptop |
| L3 | A hardened build platform: runs are isolated from each other, and the secret used to sign provenance is inaccessible to user-defined build steps | Tampering during the build by a compromised step or another tenant's run |
To place a setup on the track, check each requirement rather than the most impressive feature. Isolated runs are not enough for Level 3 if user-defined steps can still reach the provenance signing secret, for example a signing token kept in a cache that build steps can read, because a compromised step could then sign false provenance; such a setup stays at Level 2 until signing moves somewhere no build step can reach. Source requirements, such as review of changes, are not part of the Build track: SLSA 1.2 adds a separate Source track for them. SLSA provenance is expressed in the in-toto attestation format, and how provenance is produced, signed and verified at admission is covered in the KCSA lesson on supply chain, registries and admission control.
in-toto layouts, link metadata and verification
in-toto is a CNCF framework that secures the whole software supply chain by defining which steps must happen, who may perform each one, and how artifacts must flow between them, then verifying signed evidence that this is what happened.
- The layout is signed by the project owner. It lists the steps (for example clone, build, test, package), the functionaries whose keys may perform each step, a threshold of how many must sign, and artifact rules describing which files each step may consume and produce, so nothing can be swapped between steps. It can also list inspections run at verification time.
- Link metadata is produced by each functionary for its step: a signed record of the materials (inputs) and products (outputs) of that step. It is evidence for one step, not the plan.
Verification runs in order: check the layout's signature against the owner's key; reject the layout if it is past its expires date; check that each step has enough link metadata signed by functionaries the layout authorises for that step; then apply the artifact rules and inspections. A link signed by a key the layout does not list for that step counts as no valid evidence, so verification fails even though the signature itself is cryptographically valid. Each party signs only what it is responsible for: the owner signs the plan, and each functionary signs the evidence for its own step.
in-toto is not an SBOM format and not an admission policy: SBOM minimum elements come from other guidance, and admission policies are configured in the cluster. Its attestation format is what SLSA provenance and many signed SBOM attachments use.
VEX statements and OpenSSF Scorecard
VEX statements and OpenSSF Scorecard are two supply chain tools for trusting dependencies: a VEX statement says whether a known vulnerability actually affects a supplier's product, and Scorecard rates how safely an open-source project is developed.
VEX: saying whether a CVE actually affects a product
A VEX (Vulnerability Exploitability eXchange) document is a machine-readable statement from a supplier saying, for a specific product and vulnerability, whether the product is affected. The statuses are not affected, affected, fixed and under investigation; a not affected statement carries a justification, for example that the vulnerable code is never executed. Common formats are OpenVEX, CycloneDX VEX and CSAF.
VEX complements an SBOM: the SBOM says a component is present, the VEX says whether that component's known CVEs matter in this product. Scanners such as Trivy can read VEX documents and suppress the matching findings for the named product only, keeping an auditable reason. The principle for a supplier's false positive is to scope the exception to the product the supplier vouched for and to keep the inventory honest: any suppression broader than that product can hide the CVE where it really matters.
OpenSSF Scorecard: rating a dependency's security practices
OpenSSF Scorecard is an automated tool that checks an open-source project's repository for security practices and scores each check from 0 to 10, combined into an overall score. Checks include branch protection, code review, dangerous CI workflow patterns, pinned dependencies, token permissions, signed releases and whether the project is maintained. Teams use it to judge whether to trust a dependency, such as a Helm chart's upstream project, before adopting it.
A high score means the repository follows many recommended practices, which makes the project a safer dependency. It measures how the project is developed, not what the project's released artifacts contain or how anyone deploys them.
Automation and tooling: scanners and policy engine reports
Automation and tooling means running the framework checks repeatedly with tools, and each tool answers a different question, so choose it by what it inspects: node configuration, cluster posture, images, API objects or runtime behaviour.
| Tool | What it checks | Typical compliance use |
|---|---|---|
| kube-bench | CIS Benchmark checks on node files and process flags | CIS evidence for control plane and worker nodes |
| Kubescape | Security posture of a live cluster, YAML manifests or Helm charts against control frameworks (including NSA/CISA-based, CIS, and a MITRE framework built from Microsoft's ATT&CK-style Threat Matrix for Kubernetes) | One scan with a compliance score per framework |
| Trivy | Vulnerabilities in images and file systems, misconfigurations in IaC and manifests, SBOMs, and live-cluster scans with built-in compliance reports (for example the NSA specification k8s-nsa-1.0, CIS and Pod Security Standards specifications) | Compliance report of a running cluster from a tool already used in CI |
| OPA Gatekeeper, Kyverno | API objects against policies, at admission and in background audits | Lists of existing resources that break a policy |
| Falco | Runtime behaviour (system calls) on nodes | Detection evidence; not a configuration check |
| Cosign | Image signatures and attestations | Supply chain verification; not a posture scanner |
Pay attention to what a scan actually looks at: only a scan of the live cluster describes what is running now; scans of source files describe what might be deployed, and image scans describe what is inside images. Falco and runtime detection are taught in the KCSA lesson on observability.
Policy engines as compliance evidence: Gatekeeper audit and Kyverno policy reports
Admission control checks only new requests, so a policy added today never examines the resources that already exist; the audit and background-scan features of policy engines fill that gap and produce compliance evidence. Evidence about existing resources has to come from a check that evaluates those resources; the API server audit log records requests, so it holds nothing about resources created before the policy existed.
OPA Gatekeeper
- The audit controller periodically evaluates existing resources against every constraint and records the violations in each constraint's status (capped at a configurable number per constraint, 20 by default).
- The constraint's
enforcementActiondecides what happens at admission:denyblocks,dryrunblocks nothing but still reports violations through audit, andwarnadmits with a warning. Rolling out a new constraint indryrunlets teams fix violations without being blocked while compliance reads the audit results.
Kyverno
- A validate rule's failure action is Audit or Enforce (set with
validationFailureAction, or per rule withfailureActionin newer releases). Audit never blocks: the resource is created and the failure is reported. Enforce rejects the request. - With background scanning on, Kyverno periodically re-checks existing resources and writes pass and fail results to PolicyReport resources for namespaced resources and ClusterPolicyReport resources for cluster-scoped ones. These are Kubernetes objects that kubectl and reporting tools can collect as evidence.
| OPA Gatekeeper | Kyverno | |
|---|---|---|
| Report-only mode | enforcementAction: dryrun | Audit failure action |
| Checks existing resources with | Audit controller | Background scan |
| Results stored in | Each constraint's status | PolicyReport / ClusterPolicyReport |
Policy engines see API objects, so they cover Pod specs, RBAC objects and labels; they do not see kubelet flags or host file permissions, which is kube-bench's territory. How admission webhooks, ValidatingAdmissionPolicy, Gatekeeper and Kyverno work at admission time is taught in the KCSA lesson on supply chain and admission control.
Tip. Questions in this topic are short scenarios that ask you to pick the framework, document or tool that fits a stated need, to classify a threat with STRIDE or a MITRE ATT&CK tactic, or to place a build setup on the SLSA Build track. Expect near-twin distinctions: CIS levels versus Automated and Manual checks, the NSA/CISA guidance versus the CIS Benchmark, tactics versus techniques, SLSA Level 2 versus Level 3, in-toto layouts versus link metadata, and Gatekeeper audit versus Kyverno policy reports. Some scenarios hinge on where a setting lives (host configuration versus API objects) or on the difference between a point-in-time report and continuous evidence.
- CIS Level 1 is a low-impact baseline and Level 2 adds defence in depth that may limit functionality; Automated or Manual is a separate tag about how a check is assessed.
- On a managed service, assess against the provider's CIS benchmark (EKS, AKS, GKE), because the customer cannot see or fix the provider-run control plane.
- kube-bench runs on the host (a Job with hostPID and read-only hostPath mounts, or a binary) because node checks read files and process flags; WARN means a manual check a person must verify.
- The NSA/CISA guidance explains threats and practices; the CIS Benchmark lists numbered, auditable settings. NIST SP 800-190 covers image, registry, orchestrator, container and host OS risks.
- CSF 2.0 has six functions; Govern is new and holds supply chain risk management, which sat under Identify in CSF 1.1.
- Regulations state outcomes, not Kubernetes settings; PCI DSS scope includes everything connected to or able to affect card data systems, and segmentation is what shrinks it.
- A compliance report is point-in-time: drift needs scheduled checks on every node, alerts on new failures and retained timestamped results.
- Threat model during design from a data flow diagram with trust boundaries, and revisit it whenever a new flow or component appears.
- STRIDE maps to properties (spoofing-authentication, tampering-integrity, repudiation-accountability, disclosure-confidentiality, DoS-availability, elevation-authorization); ATT&CK tactics are goals and techniques are methods.
- SLSA Build L1 = provenance exists, L2 = hosted platform signs it, L3 = isolated runs and signing secrets out of reach of build steps; Gatekeeper audit/dryrun and Kyverno Audit with background scans report on existing resources without blocking.
Check yourself: 3 questions on this topic
Exam-style KCSA questions on Compliance frameworks, threat modeling, supply chain compliance and tooling, answered right here with an explanation after each. Want more? KCSA practice questions.
Frequently asked questions
What is the difference between CIS Benchmark Level 1 and Level 2?
In the CIS Kubernetes Benchmark, Level 1 recommendations form a practical baseline intended to have little impact on how the cluster is used, while Level 2 recommendations add defence in depth for environments where security is paramount and may reduce functionality. Whether a recommendation is Automated or Manual is a separate tag that describes how it is checked, not how strict it is.
What does a WARN result in kube-bench mean?
A WARN result in kube-bench means the check could not be decided automatically, usually because the CIS Benchmark marks that recommendation as Manual. A person has to verify the setting, using the remediation text kube-bench prints. A run with no FAIL results can therefore still leave WARN items to review.
How is the NSA/CISA Kubernetes Hardening Guidance different from the CIS Kubernetes Benchmark?
The NSA/CISA Kubernetes Hardening Guidance is a government publication that explains how Kubernetes is attacked and recommends practices such as least-privilege Pods, network separation, strong authentication, audit logging and timely upgrades, without a pass/fail checklist. The CIS Kubernetes Benchmark lists numbered recommendations, each with an audit procedure and remediation, which is why tools such as kube-bench audit against it. They are complementary.
Which CSF 2.0 function covers supply chain risk management?
In the NIST Cybersecurity Framework 2.0, cybersecurity supply chain risk management (category GV.SC) belongs to the Govern function, which is new in version 2.0. In CSF 1.1 the same topic sat under Identify. Policies that assign ownership of supplier risk and set security requirements for vendors of base images or Helm charts are therefore Govern activities.
How do you reduce PCI DSS scope on Kubernetes?
PCI DSS scope covers the components that store, process or transmit cardholder data plus every component connected to them or able to affect their security, which on a shared cluster can be the whole cluster. Scope is reduced by segmentation: running payment workloads in a dedicated cluster or on dedicated nodes with enforced network isolation. Hardening controls improve security but do not by themselves remove connected systems from scope.
What are the SLSA Build levels?
The SLSA 1.x Build track has levels 0 to 3. Level 1 requires provenance describing how the artifact was built. Level 2 requires a hosted build platform that generates and signs that provenance. Level 3 requires a hardened platform where build runs are isolated from each other and the provenance signing secret is inaccessible to user-defined build steps. There is no Level 4 in the current Build track.
What is a VEX document used for?
A VEX (Vulnerability Exploitability eXchange) document lets a supplier state, for a specific product and CVE, whether the product is not affected, affected, fixed or under investigation, with a justification for not affected. Scanners such as Trivy can read VEX to suppress a false positive for that product only, while still reporting the CVE in other images that really use the vulnerable code.
How do you find existing resources that break a new Gatekeeper or Kyverno policy?
Admission only checks new requests, so existing resources need an audit. OPA Gatekeeper's audit controller periodically evaluates existing resources and records violations in each constraint's status, and enforcementAction: dryrun reports without blocking. Kyverno's background scan re-checks existing resources and writes results to PolicyReport and ClusterPolicyReport resources, and a policy in Audit mode reports without blocking.
Source
This lesson covers the "Compliance and Security Frameworks" domain of the official KCSA exam guide. Vendors revise their guides — check the source for the current version.
- KCSA certification page and curriculum — The Linux Foundation
Sign up free to mark lessons complete, bookmark topics and track your exam readiness.