Fortificando el Fuerte: Estrategias Defensivas en Kubernetes y Contenedores

Actualización (15 oct 2026): ingress-nginx, el controlador del incidente de abajo, se retiró en marzo de 2026 sin más parches; Kubernetes recomienda migrar a Gateway API u otro controlador. Si usas Trivy en CI, lee la nota del stack de herramientas sobre su compromiso de marzo de 2026.

El 24 de marzo de 2025, el Security Response Committee de Kubernetes publicó CVE-2025-1974 (CVSS 9,8): cualquier cosa con acceso a la red de pods podía inyectar configuración en ingress-nginx a través de su webhook de admisión y, como el controlador lee por defecto todos los Secrets, tenía muchas posibilidades de tomar el control del clúster sin credenciales. El alcance lo decidieron dos valores por defecto: una red de pods sin segmentar y una service account que lee todos los Secrets.

Desde que Kubernetes quitó dockershim en la v1.24, los nodos suelen usar containerd o CRI-O, pero montar /var/run/docker.sock o marcar un pod con privileged: true sigue siendo un riesgo. La firma y la verificación de imágenes se tratan en blindando la cadena de suministro, y las credenciales de CI/CD, en secuestro de pipelines.

El recorrido del atacante

Supón un clúster con los namespaces dev y prod, sin NetworkPolicy y con las service accounts por defecto. Tras un RCE en una aplicación web de dev, el atacante:

  1. Lee el token de /var/run/secrets/kubernetes.io/serviceaccount/token y pregunta a la API qué puede hacer.
  2. Si puede, lista Secrets; si puede crear pods, lanza uno privilegiado con un hostPath a / y salta al nodo.
  3. Pide las credenciales del nodo al servicio de metadatos del cloud (169.254.169.254).
  4. Conecta con servicios de prod, porque un namespace no es una frontera de red.

Ejecución en el pod: imagen mínima y securityContext

Tras el RCE, el atacante busca herramientas: node:latest o python:latest, basadas en Debian, le dan shell, apt, curl y git; Alpine también trae shell (BusyBox) y apk. Para un binario estático de Go o Rust, distroless static no trae shell ni gestor de paquetes:

FROM golang:1.27.2-bookworm@sha256:5cf287a799e6b94384bad13d16b14904c531f51ba65792237e122ce42b392f61 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -trimpath -o /go/bin/app .

FROM gcr.io/distroless/static-debian13@sha256:58133991db06659feaabe0f4e97a35cebf15ef4ea08f8a4c6d2ee5f75e4aa6a0
COPY --from=build /go/bin/app /app
USER 10001:10001
ENTRYPOINT ["/app"]

El manifiesto, con service account propia sin token, imagen por digest y securityContext:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: web
  namespace: prod
automountServiceAccountToken: false
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  namespace: prod
spec:
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      serviceAccountName: web
      automountServiceAccountToken: false
      securityContext:
        runAsNonRoot: true
        runAsUser: 10001
        runAsGroup: 10001
        seccompProfile:
          type: RuntimeDefault
      containers:
        - name: web
          image: registry.example.com/app@sha256:<digest>
          ports:
            - containerPort: 8080
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities:
              drop: ["ALL"]
          volumeMounts:
            - name: tmp
              mountPath: /tmp
      volumes:
        - name: tmp
          emptyDir: {}

Con runAsNonRoot, el kubelet no arranca el contenedor como UID 0. allowPrivilegeEscalation: false activa no_new_privs (un binario setuid no puede elevar privilegios), drop: ["ALL"] retira todas las capabilities, RuntimeDefault aplica el perfil seccomp del runtime y readOnlyRootFilesystem impide escribir fuera de los volúmenes montados (aquí, /tmp). Desplegar por digest, sin parches con kubectl exec, hace que corra la imagen construida y escaneada.

Pod Security Admission (estable desde la v1.25) aplica los Pod Security Standards por namespace. Primero, un dry-run contra los pods existentes; luego, enforce, fijado a la versión menor de tu clúster (v1.37 en el ejemplo):

kubectl label --dry-run=server --overwrite ns prod \
  pod-security.kubernetes.io/enforce=restricted

kubectl label --overwrite ns prod \
  pod-security.kubernetes.io/enforce=restricted \
  pod-security.kubernetes.io/enforce-version=v1.37 \
  pod-security.kubernetes.io/warn=restricted \
  pod-security.kubernetes.io/audit=restricted

Límites: restricted no exige readOnlyRootFilesystem, y enforce actúa sobre los pods, no sobre los Deployments: un Deployment que no cumple se acepta (con aviso, por warn) y su ReplicaSet no crea los pods. Quien pueda hacer patch sobre el namespace puede relajar las etiquetas. Tampoco sustituye a parchear el runtime: CVE-2024-21626 (enero de 2024, corregido en runc 1.1.12) permitía escapar del contenedor con un descriptor de fichero filtrado.

Token de la service account y escalada en RBAC

Desde la v1.22, el token montado caduca, lo rota el kubelet y está ligado al pod: al borrar el pod, deja de ser válido. Pero con --service-account-extend-token-expiration en su valor por defecto, los tokens inyectados pueden durar hasta un año, así que uno robado vale mientras el pod exista. Si la aplicación no usa la API, automountServiceAccountToken: false lo quita (prevalece el valor del pod); una ServiceAccount por workload evita compartir la default.

Si el token existe, importa qué permite. Las buenas prácticas de RBAC señalan estas rutas de escalada:

  • get, list o watch sobre secrets (list y watch devuelven el contenido).
  • create sobre pods o workloads: permite montar cualquier Secret y usar cualquier service account del namespace.
  • get sobre nodes/proxy: la API del kubelet, sin auditoría ni admisión.
  • create sobre serviceaccounts/token, escalate, bind, impersonate y patch sobre namespaces.
  • cluster-admin y comodines (*), que cubren hasta recursos futuros.

kubectl auth can-i --list con --as=system:serviceaccount:prod:web muestra los permisos de esa service account (requiere el verbo impersonate). Esta comprobación de CI falla si encuentra una de esas rutas o no puede evaluarla (con --quiet, “no” y un error comparten código de salida; por eso lee la salida):

#!/usr/bin/env bash
# Exit 1 on an escalation path, 2 if any check cannot run.
set -euo pipefail

sa="system:serviceaccount:prod:web"
ns="prod"
found=0

check() {
  local out
  out=$(kubectl auth can-i "$@" -n "$ns" --as="$sa") || true
  case "$out" in
    yes) echo "RISK: $sa can $*" >&2; found=1 ;;
    no*) ;;
    *) echo "ERROR: could not evaluate: $*" >&2; exit 2 ;;
  esac
}

check get secrets
check list secrets
check watch secrets
check create pods
check create serviceaccounts --subresource=token
check get nodes --subresource=proxy
check patch namespaces
check impersonate users
check bind clusterroles.rbac.authorization.k8s.io
check escalate clusterroles.rbac.authorization.k8s.io
check '*' '*'

exit "$found"

Ejecútala en cada cambio de RBAC; no cubre todas las rutas (por ejemplo, crear Deployments).

Secrets: cifrados en etcd o fuera de la API

Los valores de un Secret solo van codificados en base64, que no aporta confidencialidad, y por defecto se guardan sin cifrar en etcd: quien lea etcd o un backup lo lee todo. El cifrado en reposo con KMS v2 (estable desde la v1.29) se configura en el API server con --encryption-provider-config:

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
      - secrets
    providers:
      - kms:
          apiVersion: v2
          name: cloud-kms
          endpoint: unix:///var/run/kmsplugin/socket.sock
          timeout: 3s
      # Keep identity only until every Secret has been rewritten.
      - identity: {}

Tras reiniciar el API server, kubectl get secrets --all-namespaces -o json | kubectl replace -f - reescribe cifrados los Secrets existentes; después retira identity. En EKS 1.28+, este cifrado ya viene activado con KMS v2.

Límite: esto protege etcd, no la API; quien pueda leer Secrets o crear un pod que los monte los ve en claro. Para que un valor no pase por etcd, el Secrets Store CSI Driver lo monta desde el gestor externo (salvo que actives su sincronización a Secret, en alfa) y el Vault Agent Injector lo escribe en memoria compartida. External Secrets Operator, en cambio, lo copia a un Secret nativo, en etcd.

Escape al nodo: PSA y políticas de admisión

El salto al nodo del paso 2 lo bloquea baseline en los namespaces etiquetados: prohíbe privileged, los volúmenes hostPath (también para docker.sock o el socket de containerd), hostNetwork, hostPID, hostIPC y añadir capabilities fuera de una lista corta. PSA no mira de dónde viene la imagen. Para eso está ValidatingAdmissionPolicy (estable desde la v1.30), con reglas CEL en el propio API server:

apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicy
metadata:
  name: trusted-registry-digest.example.com
spec:
  failurePolicy: Fail
  matchConstraints:
    resourceRules:
      - apiGroups: [""]
        apiVersions: ["v1"]
        operations: ["CREATE", "UPDATE"]
        resources: ["pods", "pods/ephemeralcontainers"]
  validations:
    - expression: >-
        object.spec.containers.all(c,
        c.image.startsWith('registry.example.com/') && c.image.contains('@sha256:'))
      message: "containers must use registry.example.com images pinned by digest"
    - expression: >-
        !has(object.spec.initContainers) || object.spec.initContainers.all(c,
        c.image.startsWith('registry.example.com/') && c.image.contains('@sha256:'))
      message: "initContainers must use registry.example.com images pinned by digest"
    - expression: >-
        !has(object.spec.ephemeralContainers) || object.spec.ephemeralContainers.all(c,
        c.image.startsWith('registry.example.com/') && c.image.contains('@sha256:'))
      message: "ephemeralContainers must use registry.example.com images pinned by digest"
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicyBinding
metadata:
  name: trusted-registry-digest-prod.example.com
spec:
  policyName: trusted-registry-digest.example.com
  validationActions: [Deny]
  matchResources:
    namespaceSelector:
      matchLabels:
        kubernetes.io/metadata.name: prod

pods/ephemeralcontainers cubre los contenedores que añade kubectl debug. Empieza con validationActions: [Warn, Audit] y pasa a [Deny] cuando no queden avisos. Es la alternativa nativa a la política restrict-image-registries de Kyverno del post de cadena de suministro: usa una de las dos.

El registro correcto no prueba quién firmó la imagen ni cómo se construyó; eso lo verifica ImageValidatingPolicy, en Kyverno 1.18 o posterior. Según la tabla de tipos de política, ClusterPolicy, con sus reglas verifyImages, quedó obsoleta en la 1.19 y se retirará en la 1.20. La política completa está en ese mismo post. Kyverno y OPA Gatekeeper son webhooks: con failurePolicy: Ignore, si no responden, las peticiones pasan sin validar; con Fail, se rechazan.

Salto a producción: NetworkPolicy y separación real

No existe una política de red por defecto: si ninguna NetworkPolicy selecciona un pod, todo su tráfico está permitido, también entre namespaces. Además, las aplica el plugin de red: sin un CNI que las soporte, como Calico o Cilium, no tienen efecto (flanneld no las aplica por sí solo). Compruébalo en un namespace de pruebas. La base es denegar todo y abrir DNS hacia CoreDNS, que mantiene la etiqueta k8s-app: kube-dns:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: prod
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns-egress
  namespace: prod
spec:
  podSelector: {}
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - protocol: UDP
          port: 53
        - protocol: TCP
          port: 53

Encima van las reglas de cada aplicación, como la entrada al 8080 de app: web desde el controlador de Ingress. NetworkPolicy es un recurso de namespace: cada namespace nuevo necesita las suyas (Calico y Cilium añaden políticas de clúster).

Límite: NetworkPolicy filtra en L3 y L4, sin identidad criptográfica ni cifrado. Istio usa por defecto el modo PERMISSIVE, que acepta texto en claro, hasta que aplicas una PeerAuthentication con mtls.mode: STRICT; la autorización va en AuthorizationPolicy con principals como cluster.local/ns/prod/sa/web. Y un namespace no separa tenants: dev y prod comparten API server y, si comparten nodos, kernel. La guía de multi-tenancy plantea clústeres separados; yo llevaría producción a su propio clúster y cuenta de cloud.

Metadatos del cloud

En AWS, Google Cloud y Azure, el servicio de metadatos de la instancia (IMDS) responde en 169.254.169.254, y en EKS un pod que llega a él puede heredar los permisos del nodo. El default-deny ya lo bloquea; el riesgo vuelve al abrir salida a internet. En esa regla de egress, usa ipBlock con cidr: 0.0.0.0/0 y except: ["169.254.169.254/32"].

La guía de EKS recomienda además exigir IMDSv2 con hop limit 1, para que la respuesta no llegue a los pods con namespace de red propio, y un rol por aplicación con EKS Pod Identity o IRSA. No desactives el IMDS del todo: el node termination handler, entre otros, depende de él.

aws ec2 modify-instance-metadata-options \
  --instance-id i-0123456789abcdef0 \
  --http-tokens required \
  --http-put-response-hop-limit 1 \
  --http-endpoint enabled

En GKE, Workload Identity Federation for GKE intercepta esas peticiones y entrega la identidad del pod, no la del nodo. La excepción son los pods con hostNetwork: true: GKE no les aplica esa federación y NetworkPolicy no define cómo tratarlos, otra razón para exigir baseline.

Detección y respuesta en runtime

Las reglas estables de Falco cubren varios pasos del escenario: Terminal shell in container, Contact K8S API Server From Container y Drop and execute new binary in container. Para el IMDS, el conjunto incubating trae Contact cloud metadata service from container, que no se carga por defecto: instálalo aparte (falcoctl o el chart de Helm).

Decide la respuesta de antemano: aislar el pod con una NetworkPolicy, borrarlo para invalidar su token y rotar lo que haya podido leer.

El API server no registra eventos de auditoría sin --audit-policy-file, ni los guarda sin un backend (--audit-log-path o un webhook); en EKS los logs del plano de control vienen desactivados. Esta política registra todo a nivel Metadata: quién, qué verbo y qué recurso, sin cuerpos ni valores de Secrets.

apiVersion: audit.k8s.io/v1
kind: Policy
omitStages:
  - "RequestReceived"
rules:
  - level: Metadata

Con esos eventos detectas lecturas masivas de Secrets o peticiones inesperadas a serviceaccounts/token. kube-bench compara nodos y plano de control con el CIS Kubernetes Benchmark (kube-bench run --targets master,node); en EKS o GKE, solo los nodos de trabajo. Los manifiestos se revisan en CI con trivy config o Kubescape (más en el stack de herramientas).

Lo que esto no cubre

  • Un fallo del kernel o del runtime puede saltarse securityContext y PSA; para código no confiable, la guía de multi-tenancy propone sandboxing (máquinas virtuales o kernels en espacio de usuario).
  • Una lista de hallazgos (de kube-bench, Kubescape o un escáner de imágenes) no dice cuáles se encadenan en una ruta como esta; para saberlo hay que probarla, por ejemplo con un pentest del clúster que parta de un pod comprometido.

Si solo haces tres cosas

  1. PSA restricted en cada namespace de aplicación (dry-run, o warn y audit, antes de enforce).
  2. Default-deny con DNS, verificado en tu CNI, y producción en su propio clúster.
  3. Sin token para lo que no usa la API, y la comprobación de RBAC en CI.

Automatízalo en el pipeline y en la admisión; la detección en runtime cubre lo que esos controles no bloquean.

Referencias

Blog

¿Hablamos de seguridad?

Charlas, prensa o colaboraciones: escríbeme.