Skip to content

All posts

KubernetesKyverno

NIST SP 800-190 controls for Kubernetes: what policy can enforce

Ritesh Patel

Kubernetes: NIST SP 800-190 controls for Kubernetes: what policy can enforce

NIST SP 800-190 names Kubernetes only as an example orchestrator and never defines a Kubernetes control. Its countermeasures for images, orchestrators and container runtimes do describe pod settings that an admission policy can check: non-root users, no privileged containers, no host namespaces or host paths, and constrained seccomp and capabilities. Scanning, secret delivery and runtime detection need other tools.

What SP 800-190 asks for

NIST Special Publication 800-190, the Application Container Security Guide, was published in September 2017 and is listed as final on the NIST publication page. It sorts container risks into five areas: images, registries, orchestrators, containers and the host OS. Section 3 describes the risks in each area, and Section 4 gives the countermeasures.

The guide uses “should” for its recommendations and does not map them to Kubernetes objects. Its only Kubernetes references are as an example orchestrator in Section 2.3 and in the native secrets point in Section 4.1.4. The table below is our mapping. It is not NIST guidance, and an assessor may read a countermeasure differently.

Which countermeasures a pod policy can enforce

The table pairs each SP 800-190 countermeasure with the Kubernetes setting it would touch, and says whether an admission policy can check it. Section numbers are from the PDF.

SP 800-190 section Countermeasure (paraphrased) Kubernetes setting Policy can enforce at admission?
4.1.2 Image configuration Images run as non-privileged users runAsNonRoot: true Yes. Restricted profile
4.4.3 Runtime configuration Containers run with a seccomp profile, which NIST names; constrained capabilities are our addition seccompProfile, capabilities.drop Yes. Restricted profile and sample policy
4.4.3 Runtime configuration (our mapping) Containers are not run privileged privileged Yes. Restricted profile
4.5 Host OS (our mapping) No shared host namespaces or host file access hostNetwork, hostPID, hostIPC, hostPath Yes. Restricted profile
4.3.4 Mixing sensitivity levels Sensitive and public workloads run on separate hosts Node placement, separate clusters Partly. Namespace levels do not separate hosts
4.3.3 Inter-container traffic Networks are separated by sensitivity level NetworkPolicy No from these profiles. Write a separate check
4.1.2 Image configuration No SSH or remote shell inside containers Image contents No. Admission reads the pod spec, not the image
4.1.1 Image vulnerabilities Quality gates block images above a CVSS threshold Build pipeline Partly. A scanner produces the findings in the build. Admission can require a signed attestation that the image passed the threshold
4.1.4 Embedded secrets Secrets are injected at runtime, not stored in images Secret objects No. A delivery design choice
4.3.1, 4.3.2 Access Least privilege, strong authentication, single sign-on RBAC, identity provider No. Outside admission
4.4.4 App vulnerabilities Runtime profiles detect unexpected process execution Runtime detection tool No

Pod Security Admission: the restricted profile

Pod Security Admission is built into Kubernetes and enforces the Pod Security Standards at the namespace level. The restricted profile is the one that lines up with the countermeasures above.

  1. Read the restricted rules. The Pod Security Standards page says the policies “are cumulative”, so restricted includes the baseline rules. Those say privileged containers “must be disallowed”, hostPath volumes “must be forbidden”, and sharing the host namespaces “must be disallowed”. The restricted rules also require runAsNonRoot to be true and allowPrivilegeEscalation to be false.
  2. Check the capability and seccomp rules. Containers must drop ALL capabilities and may add back only NET_BIND_SERVICE. The seccomp profile must be set explicitly to an allowed value, and both Unconfined and an absent profile are prohibited.
  3. Label each namespace with the mode and level you want. The Pod Security Admission page gives the label form, with enforce, audit and warn as the modes and privileged, baseline and restricted as the levels.
apiVersion: v1
kind: Namespace
metadata:
  name: restricted-apps
  labels:
    pod-security.kubernetes.io/enforce: privileged   # observe first; switch to restricted after you fix the warnings
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/warn: restricted
  1. Read the warnings and audit annotations before you change enforce. The page says audit adds an annotation to the audit log and warn shows a message, and that a namespace can set any or all modes.

The page checked is the Kubernetes v1.37 documentation, as of 2026-11-17. Check the version your cluster runs before you pin the -version label.

A Kyverno policy for dropped capabilities

The restricted profile requires containers to drop all capabilities. Kyverno’s sample library has a policy for the same check, written as a ValidatingPolicy. The sample runs in Audit mode, so it reports pods that do not drop ALL and does not block them. The sample also skips images listed in exceptions.allowedImages.

apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata:
  name: drop-all-capabilities
  annotations:
    policies.kyverno.io/title: Drop All Capabilities in VPOL
    policies.kyverno.io/category: Best Practices in VPOL
    policies.kyverno.io/severity: medium
    kyverno.io/kubernetes-version: "1.30"
    policies.kyverno.io/minversion: 1.19.1
    policies.kyverno.io/subject: Pod
spec:
  validationActions:
    - Audit
  evaluation:
    background:
      enabled: true
  matchConstraints:
    resourceRules:
      - apiGroups:
          - ""
        apiVersions:
          - v1
        operations:
          - CREATE
          - UPDATE
        resources:
          - pods
  variables:
    - name: allContainers
      expression: object.spec.containers + object.spec.?initContainers.orValue([]) + object.spec.?ephemeralContainers.orValue([])
  validations:
    - expression: variables.allContainers.all(container, (has(exceptions.allowedImages) && container.image in exceptions.allowedImages) || container.?securityContext.?capabilities.?drop.orValue([]).exists(capability, capability.upperAscii() == 'ALL'))
      message: Containers must drop `ALL` capabilities.

Read the policy report before you change anything. The sample reports on the pods that match it, so the first run shows which workloads need a fix or an exception.

What policy cannot reach

Several countermeasures in Section 4 describe behaviour, not configuration. A pod spec cannot show them.

Section 4.4.4 asks for container-aware tools that profile each app and detect anomalies at runtime, including “invalid or unexpected process execution”. Section 4.1.1 asks for vulnerability visibility across all image layers and quality gates in the build. A scanner has to produce those findings. Admission can enforce the outcome only if the pipeline signs an attestation that the image passed, and a Kyverno verifyImages rule requires it, as in our NIST 800-53 mapping guide. Section 4.3.2 asks for multifactor authentication and single sign-on to the orchestrator. Section 4.1.4 asks that secrets be provided at runtime and encrypted at rest and in transit.

Apart from the signed-attestation option for 4.1.1, none of these is a pod field, so a Kubernetes admission policy cannot check them. Record each one with the tool or process that covers it, and an owner, so the gap is visible to an assessor.

Gotchas from the fine print

Several rules in the Kubernetes docs change what a policy actually blocks.

Enforce does not apply to workload templates. The Pod Security Admission page says that audit and warn apply to workload resources such as Deployments, but “enforce mode is not applied to workload resources, only to the resulting pod objects”. A Deployment with a privileged pod template is accepted, and its pods are rejected.

Exemptions must be listed. The page says exemptions “must be explicitly enumerated” in the admission controller configuration, and that requests meeting an exemption are ignored.

Container settings can be left out. The restricted profile allows a container’s runAsNonRoot to be undefined if the pod-level runAsNonRoot is true. A policy that checks only container fields will flag pods that are correct.

Audit mode is not a control. A policy in Audit mode records a failure and admits the pod. It satisfies a countermeasure only once someone reads and acts on the report.

A checklist before you map the controls

  1. List the SP 800-190 countermeasures that apply to your platform, and mark which ones are image, registry, orchestrator, runtime or host controls.
  2. For each pod-level control, pick Pod Security Admission or a policy engine, and write the check against the pod field it reads.
  3. Put each non-pod control on the list with its owner: build pipeline, RBAC, identity provider, runtime detection or the operating process.
  4. Run the namespace labels in warn and audit first, then read the results for each workload.
  5. Keep the mapping in version control, with the Kubernetes and policy-engine versions you checked against.

Enforcing this with Kyverno

Kyverno is open source. It can express the pod-level rows of the table as policies, and its sample library includes the capability check shown in this post. Pod Security Admission covers the restricted profile without an extra tool, and a policy engine adds checks it does not include.

Read the continuous compliance hub for the wider approach, and the Kyverno project page for the tool. For the same control-by-control method on other frameworks, read the NIST 800-53 mapping guide, the SOC 2 controls post, the PCI DSS post and the SEBI CSCRF post.

Sources checked on 2026-11-17: the NIST SP 800-190 publication page and PDF, the Kubernetes Pod Security Admission page, the Kubernetes Pod Security Standards page, and the Kyverno sample policy page.

Frequently asked questions

Does NIST SP 800-190 mention Kubernetes?

Only in passing. SP 800-190, the Application Container Security Guide, lists Kubernetes among orchestrators and cites it for native secret management. It does not define Kubernetes settings such as pod fields or NetworkPolicy. To use its countermeasures on a cluster, you translate each one into a pod setting or a process that a policy or a person can check. The mapping in this guide is one way to do that.

Can an admission policy satisfy an SP 800-190 countermeasure on its own?

Only for countermeasures that describe a pod setting, such as running as a non-root user or dropping capabilities. Countermeasures about producing vulnerability findings, runtime anomaly detection, secret delivery and administrator access need other controls. A policy report shows that a configuration check passed for a resource. It does not show that a container is free of known vulnerabilities.

Does Pod Security Admission cover all of the pod-level countermeasures?

No. The restricted profile covers privileged containers, host namespaces, hostPath volumes, hostPorts, privilege escalation, running as root, seccomp and capabilities. It does not cover NetworkPolicy, RBAC, image contents or encryption. Those need their own checks, and the Pod Security Standards page lists the exact fields the profile reads.

Should I start with enforce mode for SP 800-190 policies?

Start with audit or warn mode. Pod Security Admission warns and audits without rejecting pods, and Kyverno's sample policy in this guide uses the Audit validation action. Read the results per workload, fix the failures and record exceptions with an owner. Switch to enforce only when the namespace has no open failures.

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.