Where Kubernetes risk actually comes from
Most of the Kubernetes incidents we get called into do not start with a clever exploit. They start with a default nobody changed, an image nobody scanned, or a service account token that was mounted into a pod that never needed it. The cluster was doing exactly what it was told. The problem was what it was told.
ByteByteGo recently described Kubernetes as a system of promises rather than a script, and that framing is worth borrowing. A script is a sequence of steps that runs once. A promise is a desired state that something keeps checking and repairing. Kubernetes is built entirely on the second idea: you declare what should be true, and a set of controllers works continuously to make reality match. That design is why Kubernetes survives node failures and traffic spikes without a human in the loop. It is also why a bad security posture is so durable. If you declare a privileged pod with host network access, the platform will keep that pod alive, reschedule it when it dies, and defend that insecure state as faithfully as it defends a locked-down one.
The threats around those clusters have shifted at the same time. In its 2026 Software Supply Chain Security Report, ReversingLabs reported a 73% jump in detections of malicious open-source packages during 2025, including the first registry-native worm, Shai-Hulud, and the compromise of several widely used packages through dependency confusion, typosquatting, and CI/CD manipulation. Cyber Magazine's reporting through the year told the same story from the boardroom: Nissan moving to predictive procurement to screen third-party suppliers, Deutsche Telekom rebuilding its group security strategy around infrastructure hardening, Palo Alto Networks pitching cloud and data-centre security "by design." Different industries, one direction of travel. The attack surface that matters now sits in your build pipeline and your cluster configuration, not just at the network edge.
A control loop is not a security control
It helps to be precise about what Kubernetes gives you for free and what it does not. The reconciliation loops at the heart of the platform guarantee availability and convergence. They do not make judgements about safety. A Deployment controller will happily run ten replicas of a container pulled from an untrusted registry. The scheduler will place a pod that requests every Linux capability on the box. RBAC ships permissive enough to get people started, network traffic between pods is allowed by default, and a pod gets a mounted service account token whether or not it ever talks to the API server.
None of that is a flaw in Kubernetes. It is a set of decisions the platform deliberately leaves to you, because the platform cannot know your risk tolerance. The work of hardening is the work of narrowing those defaults down to what your workloads actually need, and then making the cluster enforce the narrowed version automatically. Do it manually and it erodes within a sprint. The only version that holds is the one wired into admission control and policy, so the same reconciliation machinery that keeps your app running also keeps your guardrails running.
The three planes where clusters get compromised
When we scope a cluster review, we split the problem into three planes: the supply chain that produces what runs, the configuration and control plane that decides how it runs, and the runtime where it actually executes. An attacker only needs one of the three to be soft. A defensible cluster treats all three as separate layers, so a failure in one does not hand over the others.
The supply chain: everything you didn't write
A modern container image is mostly other people's code. Base image, language runtime, and a long tail of transitive dependencies you never chose directly. That is where the 73% increase lives. The defense is not a single scanner but a chain of checks, each of which has to pass before an image is allowed near production.
Start by generating a software bill of materials for every image at build time, so you know exactly what shipped and can answer "are we affected?" in minutes instead of days when the next Log4Shell lands. Scan images with a tool like Trivy or Grype for known vulnerabilities and, increasingly, for known-malicious packages, and fail the build on anything above your agreed severity threshold rather than filing it as a warning. Sign your images with Sigstore's cosign so provenance is verifiable, and adopt the SLSA framework's levels as a maturity target for how tamper-resistant your build process is. Then close the loop inside the cluster: use an admission controller to reject any image that is unsigned, comes from a registry you do not trust, or carries an unresolved critical finding. Pin images by digest, not by a floating tag like latest, because a tag is a promise anyone with push access to the registry can quietly break.
This is also where third-party risk becomes concrete. Nissan's move to screen suppliers before they enter the procurement chain is the same instinct as refusing an unsigned image at admission: verify provenance before you take a dependency, not after it is already running in production.
Configuration and the control plane
If the supply chain governs what runs, configuration governs how much damage it can do once it is running. This is the plane with the highest ratio of effort to payoff, because most of the controls are one-time policy decisions that then enforce themselves.
Benchmark the cluster against the CIS Kubernetes Benchmark and run kube-bench on your nodes to see how far the real configuration has drifted from it. NIST SP 800-190, the Application Container Security Guide, is the companion document worth reading alongside it. From there, the controls that consistently earn their keep are:
- Pod Security Standards. PodSecurityPolicy was removed in Kubernetes 1.25. Its replacement, Pod Security Admission enforcing the Baseline and Restricted standards, blocks the privileged, host-mounting, root-running pods that turn a single container escape into node compromise. Enforce Restricted on every namespace that can tolerate it.
- Least-privilege RBAC. No wildcard verbs, no cluster-admin handed out for convenience, and a hard look at who can create pods, read secrets, or exec into containers. In practice, the right to exec into a pod is the right to become that pod.
- Default-deny NetworkPolicies. East-west traffic between pods is open unless you close it. Start with a default-deny policy per namespace and allow only the flows the application actually uses, so a compromised pod cannot freely pivot across the cluster.
- Secrets handled like secrets. Turn on encryption at rest for etcd with a KMS provider, stop mounting the default service account token where it is not needed, and pull sensitive values from an external manager such as Vault or a cloud secrets service rather than baking them into manifests.
- A locked-down API server. The Kubernetes API is the front door to everything. It should not be reachable from the open internet, anonymous auth should be off, and the audit log should be on and shipped somewhere you actually read it.
Runtime: what happens after the pod starts
Supply chain and configuration are preventive. Runtime is where you accept that prevention is never total and build the ability to see and stop an attack in progress. A container that was clean at admission can still be exploited through an application vulnerability an hour later, and nothing in the first two planes will notice.
Harden the workload itself first: run as a non-root user, mount the root filesystem read-only, and drop every Linux capability you do not explicitly need. These three settings alone remove a large share of post-exploitation options. On top of that, deploy runtime detection. Tools like Falco, many now built on eBPF, watch for the behaviour that signals compromise regardless of which CVE let the attacker in: a shell spawning inside a container that should never run one, an unexpected outbound connection, a write to a path that should be immutable. Those signals are only useful if someone acts on them, which is why runtime events and the API audit log belong in your SIEM and in front of a SOC, not in a dashboard nobody watches at 3am.
A hardening baseline
The controls above map cleanly onto the three planes. The table below is the baseline we start most engagements from. It is deliberately tool-agnostic where it can be, because the standard matters more than the vendor.
| Plane | Control | Standard or tool | What it stops |
|---|---|---|---|
| Supply chain | SBOM + vulnerability and malware scan on build | Trivy, Grype, Syft | Shipping known-vulnerable or malicious dependencies |
| Supply chain | Image signing and admission verification | Sigstore cosign, SLSA | Running unsigned or tampered images |
| Configuration | Benchmark and drift check | CIS Kubernetes Benchmark, kube-bench | Insecure cluster and node defaults |
| Configuration | Pod Security Admission (Restricted) | Pod Security Standards | Privileged, host-mounting, root pods |
| Configuration | Least-privilege RBAC + default-deny network | Native RBAC, NetworkPolicy | Lateral movement and privilege escalation |
| Configuration | Policy-as-code enforcement | OPA Gatekeeper, Kyverno | Non-compliant workloads reaching the cluster |
| Configuration | Secrets encryption and externalisation | etcd KMS, Vault, External Secrets | Plaintext secrets in etcd and manifests |
| Runtime | Non-root, read-only FS, dropped capabilities | SecurityContext | Container escape and post-exploitation |
| Runtime | Behavioural detection + audit to SOC | Falco, eBPF, SIEM | Attacks that bypass preventive controls |
Rolling it out without breaking production
The reason clusters stay unhardened is rarely ignorance. It is fear of breaking a running platform, and that fear is reasonable. A default-deny NetworkPolicy applied blind will take down services that depended on traffic nobody documented. The way through is to sequence the work and to run every enforcing control in a warn-or-audit mode before it blocks anything.
- Measure first. Run kube-bench and an image scan across the current estate. You cannot prioritise what you have not quantified, and the report is also your before-and-after evidence for auditors.
- Get the supply chain gate in place. SBOM, scanning, and signing in the build pipeline change nothing about running workloads, so they are the safest high-value starting point.
- Turn on policy in audit mode. Deploy Gatekeeper or Kyverno and Pod Security Admission set to warn, not enforce. Collect the violations for a sprint or two. The list of what would have been blocked is your real backlog.
- Fix the workloads, then flip to enforce. Work through the violation list namespace by namespace. Only when a namespace is clean do you move its policy from warn to enforce.
- Introduce network policy incrementally. Default-deny one namespace at a time, using observed traffic to write the allow rules, rather than one cluster-wide change on a Friday afternoon.
- Wire runtime detection into the SOC. Stand up Falco and route its events, plus the API audit log, into your SIEM with real alerting rules and an owner.
Every step in that order is either non-disruptive or reversible, and each one produces evidence you can hand to an assessor.
How this maps to the audits you already have to pass
For most of the organisations we work with in banking, telecom, and critical national infrastructure, hardening is not an abstract goal. It is how you produce evidence for a framework you are already committed to. The good news is that a well-hardened cluster generates that evidence as a by-product.
ISO 27001's Annex A controls for secure configuration, access control, and logging map almost directly onto the CIS benchmark, RBAC, and audit-log work above. PCI-DSS requirements for segmentation and change control line up with NetworkPolicies and policy-as-code. The NIST Cybersecurity Framework's Identify, Protect, Detect functions correspond to the SBOM inventory, the preventive configuration controls, and runtime detection respectively. SOC 2's common criteria lean on exactly the access, change, and monitoring evidence that a hardened pipeline emits automatically. Build the controls once, in enforceable form, and the audit stops being a scramble to reconstruct what the cluster was doing and becomes an export of what it has been enforcing all along.
How Aydahwa Enterprise Can Help
We build and secure Kubernetes and container platforms for organisations that cannot afford to treat security as a phase-two problem. Our team holds credentials including ISO 27001, PCI-DSS, and Microsoft Cybersecurity Architect Expert, and we work against the same standards named throughout this article: CIS Benchmarks, NIST CSF, and NIST SP 800-190. In practice that means a cluster review that tells you where you actually stand, a hardening roadmap sequenced so it does not break production, and admission and runtime controls wired in so the posture holds after we leave.
If you are running containers in production and are not certain your supply chain, configuration, and runtime are all covered, that uncertainty is the finding. Start with our free cyber security self-assessment or work through the cybersecurity readiness checklist to see where the gaps are. You can read more about how we approach cybersecurity and cloud security and migration, or get in touch to scope a Kubernetes hardening review for your environment.



