Ciberseguridad ·

Implementación de mTLS entre microservicios con Istio y CFSSL en Kubernetes

Introducción

En entornos de microservicios, la comunicación segura entre pods es fundamental para prevenir ataques de man‑in‑the‑middle, suplantación de identidad y fuga de datos. Istio provee una capa de servicio mesh que permite habilitar mutual TLS (mTLS) de forma declarativa, mientras que CFSSL (CloudFlare's PKI toolkit) puede actuar como Certificate Authority (CA) interna para emitir y rotar certificados automáticamente.

Este artículo muestra, con ejemplos reales, cómo:

  • Instalar Istio en un clúster Kubernetes.
  • Desplegar CFSSL como CA interna y configurar su API.
  • Integrar CFSSL con Istio para que la propia malla use certificados emitidos por la CA.
  • Validar la comunicación mTLS entre dos microservicios.
  • Resolver problemas frecuentes.

1. Preparación del entorno

1.1 Requisitos previos

  • Kubernetes 1.24+ (cluster con kubectl configurado).
  • Helm 3.x instalado.
  • Acceso a una máquina con openssl y curl.
  • Permisos de cluster‑admin para instalar CRDs.

1.2 Instalación de Istio

Utilizaremos la versión 1.20.0 (última LTS a la fecha). Descargamos el paquete y lo instalamos con Helm:

# Descargar Istio
curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.20.0 TARGET_ARCH=x86_64 sh -

Añadir binario al PATH

export PATH=$PWD/istio-1.20.0/bin:$PATH

Instalar CRDs

istioctl install —set profile=default -y

Verificamos que los pods del namespace istio-system estén en estado Running:

kubectl get pods -n istio-system

1.3 Despliegue de CFSSL

Crearemos un deployment sencillo que exponga la API de CFSSL sobre HTTP (en producción usar TLS y autenticación). Primero, un ConfigMap con la configuración de la CA:

cat > cfssl-config.yaml <<EOF
apiVersion: v1
kind: ConfigMap
metadata:
  name: cfssl-config
  namespace: istio-system
data:
  ca-config.json: |
    {
      "signing": {
        "default": {
          "usages": ["signing","digital signature","key encipherment","server auth","client auth"],
          "expiry": "8760h"
        },
        "profiles": {
          "istio": {
            "usages": ["signing","digital signature","key encipherment","server auth","client auth"],
            "expiry": "8760h"
          }
        }
      }
    }
  ca-csr.json: |
    {
      "CN": "Istio-CA",
      "key": { "algo": "rsa", "size": 4096 },
      "names": [ { "C": "ES", "ST": "Madrid", "L": "Madrid", "O": "MyOrg", "OU": "Security"} ]
    }
EOF

kubectl apply -f cfssl-config.yaml

Ahora el Deployment que ejecuta el contenedor oficial de CFSSL:

cat > cfssl-deployment.yaml <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cfssl
  namespace: istio-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app: cfssl
  template:
    metadata:
      labels:
        app: cfssl
    spec:
      containers:
      - name: cfssl
        image: cfssl/cfssl:latest
        args: ["serve","-ca","/etc/cfssl/ca-csr.json","-ca-key","/etc/cfssl/ca-key.pem","-config","/etc/cfssl/ca-config.json"]
        volumeMounts:
        - name: cfssl-config
          mountPath: /etc/cfssl
      volumes:
      - name: cfssl-config
        configMap:
          name: cfssl-config
EOF

kubectl apply -f cfssl-deployment.yaml

Exponemos el servicio interno:

cat > cfssl-service.yaml <<EOF
apiVersion: v1
kind: Service
metadata:
  name: cfssl
  namespace: istio-system
spec:
  ports:
  - port: 8888
    targetPort: 8888
    name: http
  selector:
    app: cfssl
EOF

kubectl apply -f cfssl-service.yaml

2. Configuración de Istio para usar la CA externa

2.1 Generación del certificado raíz con CFSSL

Primero, creamos la clave y el certificado raíz de la CA:

# Generar clave privada
openssl genrsa -out ca-key.pem 4096

Generar CSR usando la plantilla del ConfigMap

cfssl gencert -initca cfssl-config/ca-csr.json | cfssljson -bare ca

El resultado: ca-key.pem, ca.pem

Subimos el certificado raíz a Istio como Secret:

kubectl create secret generic istio-ca-secret \
  -n istio-system \
  --from-file=ca-key.pem=ca-key.pem \
  --from-file=ca-cert.pem=ca.pem

2.2 Modificar el control plane de Istio

Indicamos a Istio que use nuestra CA mediante la opción security.selfSigned desactivada y la ruta al secret:

istioctl install \
  --set values.global.controlPlaneSecurityEnabled=true \
  --set values.security.selfSigned=false \
  --set values.security.istiod.enabled=true \
  --set values.security.istiod.secretName=istio-ca-secret \
  -y

Con esta configuración, istiod firmará los certificados de los sidecar proxies con la CA que hemos provisto.

2.3 Verificación de los certificados emitidos

Desplegamos un pod de prueba y revisamos su certificado:

kubectl run -i --tty test-pod --image=alpine --restart=Never -- sh
apk add --no-cache curl openssl
# Dentro del pod:
curl -s http://istiod.istio-system.svc:15012/metrics | grep 'pilot_cert_expiration_seconds'
# O inspeccionar el certificado del sidecar:
openssl x509 -in /etc/certs/cert-chain.pem -text -noout | grep Issuer

3. Habilitación de mTLS entre microservicios

3.1 Deploy de dos microservicios de ejemplo

Crearemos frontend y backend usando la imagen hashicorp/http-echo:

cat > microservices.yaml <<EOF
apiVersion: v1
kind: Namespace
metadata:
  name: demo
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
  namespace: demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: backend
        image: hashicorp/http-echo
        args:
        - "-text=Hello from backend"
        ports:
        - containerPort: 5678
---
apiVersion: v1
kind: Service
metadata:
  name: backend
  namespace: demo
spec:
  ports:
  - port: 80
    targetPort: 5678
  selector:
    app: backend
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  namespace: demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: curlimages/curl
        command: ["/bin/sh","-c","while true; do sleep 5; done"]
        ports:
        - containerPort: 80
EOF

kubectl apply -f microservices.yaml

3.2 Política de mTLS con Istio

Aplicamos un PeerAuthentication que obliga al modo STRICT en el namespace demo:

cat > mtls-policy.yaml <<EOF
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: demo
spec:
  mtls:
    mode: STRICT
EOF

kubectl apply -f mtls-policy.yaml

Con STRICT, cualquier intento de conexión sin TLS será rechazado.

3.3 Prueba de conectividad

Ingresamos al pod frontend y realizamos una petición HTTP a backend:

kubectl exec -n demo -it $(kubectl get pod -n demo -l app=frontend -o jsonpath="{.items[0].metadata.name}") -- sh
# Dentro del contenedor:
curl -v http://backend

Deberíamos obtener el mensaje Hello from backend y, en los logs de istio-proxy, ver que la conexión se realizó mediante mTLS. Si la política está funcionando, un intento sin TLS (por ejemplo, usando curl http://backend --http1.0 en modo no‑TLS) producirá 403 Forbidden.

4. Troubleshooting y errores comunes

4.1 Certificados no firmados por la CA interna

  • Síntoma: Los pods aparecen con DISABLED en la salida de istioctl proxy-status.
  • Causa típica: istiod no pudo leer el secret istio-ca-secret.
  • Solución: Verificar que el secret exista y que istiod tenga permiso get sobre él:
    kubectl get secret istio-ca-secret -n istio-system
    kubectl describe pod -n istio-system -l app=istiod
    

4.2 mTLS no activado a pesar de la política

  • Síntoma: curl -v http://backend funciona pero los logs de istio-proxy no muestran “TLS handshake”.
  • Causa: El namespace no tiene el label istio-injection=enabled o el sidecar no se inyectó.
  • Pasos:
    kubectl label namespace demo istio-injection=enabled --overwrite
    kubectl rollout restart deployment -n demo
    kubectl get pods -n demo
    # Verificar que cada pod tenga 2 contenedores (app + istio-proxy)
    

4.3 Errores de CFSSL (502 Bad Gateway)

  • Síntoma: Cuando Istio solicita un certificado, la llamada a http://cfssl:8888/api/v1/cfssl/sign falla.
  • Causa: La API de CFSSL no está escuchando en el puerto correcto o el endpoint está protegido.
  • Solución: Confirmar que el contenedor CFSSL está corriendo:
    kubectl logs -n istio-system -l app=cfssl
    kubectl port-forward -n istio-system svc/cfssl 8888:8888
    curl http://localhost:8888/api/v1/cfssl/info
    
    Ajustar el comando de inicio del contenedor si hace falta el flag -address 0.0.0.0.

4.4 Rotación de certificados

Istio rota automáticamente los certificados cada 24 h. Si la CA cambia, se debe actualizar el secret y reiniciar istiod:

# Actualizar secret
kubectl create secret generic istio-ca-secret \
  -n istio-system \
  --from-file=ca-key.pem=new-ca-key.pem \
  --from-file=ca-cert.pem=new-ca.pem \
  --dry-run=client -o yaml | kubectl apply -f -

Reiniciar istiod

kubectl rollout restart deployment istiod -n istio-system

Conclusión

Implementar mTLS entre microservicios con Istio y una CA interna automatizada mediante CFSSL brinda una capa de seguridad robusta y gestionable en Kubernetes. La integración descrita permite:

  • Control total sobre la cadena de confianza mediante una CA propia.
  • Rotación automática de certificados sin intervención humana.
  • Políticas granulares de autenticación y autorización usando los recursos de Istio.
  • Visibilidad y trazabilidad de las conexiones mediante los registros de sidecar.

Adoptar esta arquitectura reduce la superficie de ataque y ayuda a cumplir con requisitos de cumplimiento (PCI‑DSS, GDPR, etc.). Con los pasos y ejemplos proporcionados, los sysadmins pueden replicar la solución en entornos de producción, adaptando la exposición de CFSSL a HTTPS y añadiendo mecanismos de autenticación (API keys, mTLS propio) según sus políticas de seguridad.