Skip to content

All posts

Kubernetes

NIST CSF 2.0 and Kubernetes: which controls policy can enforce

Ritesh Patel

Kubernetes: NIST CSF 2.0 and Kubernetes: which controls policy can enforce

NIST CSF 2.0 is an outcome framework and never names Kubernetes. A policy engine can evidence some outcomes: platform security settings in PR.PS, least-privilege access in PR.AA, and resource capacity in PR.IR. Governance, risk assessment, monitoring, patching and incident response need records and tools outside admission control.

What CSF 2.0 asks for, and what it leaves open

CSF 2.0 has six Functions: GOVERN, IDENTIFY, PROTECT, DETECT, RESPOND and RECOVER. Each Function divides into Categories, and each Category into Subcategories that state an outcome. The framework is explicit that it is not a control list. In its words, “These outcomes are not a checklist of actions to perform; specific actions taken to achieve an outcome will vary by organization and use case.”

That matters for Kubernetes because the framework says nothing about pods. It says the Functions “apply to all types of technology environments, including cloud, mobile, and artificial intelligence systems.” So the question is which Subcategory a given cluster setting supports, and that mapping is ours, not NIST’s.

Which CSF 2.0 outcomes a policy can check

The table below pairs the Subcategories most relevant to a cluster with the Kubernetes setting that would evidence each one. The last column says whether an admission policy can read that setting. Outcome wording is abbreviated from CSWP 29.

CSF 2.0 Subcategory Outcome (abbreviated) Kubernetes setting Policy can check it?
PR.PS-01 Configuration management practices are established and applied Pod securityContext fields Yes, for the fields the Pod Security Standards list
PR.AA-01 Identities and credentials for services are managed automountServiceAccountToken Yes, for the field
PR.AA-05 Permissions follow least privilege RBAC roles and bindings Partly. A policy can flag wildcards and cluster-admin bindings
PR.IR-01 Environments are protected from unauthorized logical access NetworkPolicy objects Partly. A policy can require one, not test the traffic it allows
PR.IR-04 Adequate resource capacity is maintained CPU and memory limits Yes, for the presence of limits
PR.PS-05 Unauthorized software execution is prevented Image reference, digest, signature Partly. Admission reads the reference, not the contents
PR.PS-02 Software is maintained, replaced and removed commensurate with risk Image versions and scan results Partly. A policy can check image versions and signed scan attestations. It cannot patch the image or the node
PR.PS-04 Log records are generated Audit logging configuration No. Admission does not see log output
DE.CM-09 Runtime environments are monitored Runtime detection sensors No
ID.RA-01 Vulnerabilities are identified and recorded Scanner findings No

Pod settings behind PR.PS-01

Several rows of the table map to PR.PS-01 because each one is a pod setting a policy can read. The Pod Security Standards page says “Privileged Pods disable most security mechanisms and must be disallowed,” and that “HostPath volumes must be forbidden.”

Checked against the Kubernetes docs as fetched on 2026-11-18. The restricted profile checks these fields:

  1. Privileged containers: privileged must be unset or false.
  2. Host namespaces: hostNetwork, hostPID and hostIPC must be unset or false.
  3. Privilege escalation: allowPrivilegeEscalation must be false.
  4. Non-root: runAsNonRoot must be true, set at pod or container level.
  5. Capabilities: containers must drop ALL, and may add back only NET_BIND_SERVICE.
  6. Seccomp: the profile must be RuntimeDefault or Localhost, and must not be Unconfined.

Two gotchas come from the fine print. The privilege escalation, capability and seccomp rules are Linux-only from Kubernetes 1.25. And the restricted profile permits only a short list of volume types, so a hostPath volume fails it by design.

Access and service accounts under PR.AA-05

PR.AA-05 asks that permissions be “defined in a policy, managed, enforced, and reviewed, and incorporate the principles of least privilege.” Kubernetes RBAC enforces the permissions itself. A policy’s job is to check the objects that grant them.

The RBAC good-practices page advises that you “Avoid providing wildcard permissions when possible, especially to all resources,” and that you “Avoid the default auto-mounting of service account tokens by setting automountServiceAccountToken: false.” A policy can flag a ClusterRoleBinding to cluster-admin or a wildcard verb, but it cannot decide that a binding is needed. That decision stays with the owning team and needs a recorded reason.

Where policy stops

A passing policy result means one configuration check held for one resource at admission. It does not mean a control is met across the organization. The checklist page makes a similar point about images: container images are “regularly scanned during creation and in deployment,” and admission can check only the reference or signature it is given.

Treat each CSF row as evidence. A policy report can support PR.PS-01 for a namespace. It cannot support GV.OC or DE.CM on its own, so pair it with scanner output, change records and monitoring that the team owns.

Using a profile to scope the work

CSF 2.0 describes an Organizational Profile as a way to record current and target outcomes. Its first step is to scope the profile, and the framework notes that a profile “could address an entire organization or be scoped to an organization’s financial systems.” For a cluster, scope it to one platform or one namespace group, not to the whole company.

The steps below are our procedure, built on that first NIST step:

  1. Scope the profile to the cluster or namespaces it covers.
  2. Mark each relevant Subcategory as one a policy can evidence, a process outcome, or a tool outcome.
  3. Start the policies in audit or warn mode and review the results.
  4. Record an owner and an expiry for every exception.
  5. Move a namespace to enforce mode only when no open failures remain.

Enforcing these controls on a cluster

Admission control is the enforcement point for the settings in the first table. The checklist page says that memory and CPU limits “can be enforced by an admission controller,” and that the Pod Security Standards “can be enforced at the namespace level with the new Pod Security admission.”

For the wider approach to keeping this evidence current, read the continuous compliance hub. The NIST SP 800-190 post uses the same method for container security guidance, and the NIST 800-53 mapping guide covers a control catalog that is closer to an audit baseline.

Sources

Frequently asked questions

Does NIST CSF 2.0 mention Kubernetes?

No. CSF 2.0 is a taxonomy of cybersecurity outcomes that is sector-, country- and technology-neutral. It says it applies to cloud and artificial intelligence systems, but it does not name Kubernetes or describe pod fields, RBAC objects or network policies. To use it on a cluster, you decide which outcomes apply, then pick the Kubernetes settings that evidence each one. The mapping in this guide is our own.

Can an admission policy show that a CSF 2.0 outcome is achieved?

Only for outcomes that describe a setting a policy can read, such as privilege, host access or resource limits. A policy result shows that a resource passed a check when it was admitted. It does not show that the organization manages risk, patches software or detects attacks. Those outcomes need records, scans and monitoring from other tools and people.

Which CSF 2.0 function should a platform team start with?

Start with PROTECT, and specifically the Platform Security category, PR.PS. Its configuration management outcome (PR.PS-01) is the one most pod policies can evidence. Access (PR.AA) and resource capacity (PR.IR-04) come next. GOVERN, IDENTIFY, DETECT and RESPOND depend on processes that a cluster policy cannot supply on its own.

Should CSF policies block workloads or only report on them?

Begin in audit or warn mode. Pod Security admission supports warn, audit and enforce modes, so you can see which workloads would fail before any are rejected. Review the failures per workload, fix them, and record an owner for any exception. Move a namespace to enforce only after it has no open failures that the owning team has not accepted.

Ritesh Patel, Founder & VP Product, Nirmata

Ritesh Patel is a founder of Nirmata and leads its products. He writes about governing AI coding agents, MCP security and Kubernetes policy as code.

LinkedIn

Nirmata Control HubOne control plane for Kyverno policies.
Share

Stay up-to-date with the latest in AI, governance, and infrastructure

Subscribe to our free monthly newsletter to get industry news, DevOps tips, and articles right to your inbox on Kyverno, containerization, Kubernetes deployment & management and more.