← volver

Automatización de rotación y renovación de certificados TLS internos con ACME, Vault y Bash

Por · · [Ciberseguridad] · lectura estimada: ~5 min

Introducción

Los certificados TLS internos garantizan la confidencialidad e integridad de la comunicación entre servicios en infraestructuras híbridas. La renovación manual es propensa a errores y rompe la disponibilidad. En este artículo describimos cómo combinar ACME (Automated Certificate Management Environment), HashiCorp Vault y scripts Bash para crear una cadena de automatización que funcione tanto en datacenters on‑prem como en proveedores cloud (AWS, Azure, GCP).

Al final tendrás:

  • Un issuer ACME interno en Vault.
  • Políticas de Vault que limitan la emisión a dominios internos.
  • Un script Bash que solicita, almacena y despliega certificados.
  • Un proceso de cron o systemd timer que ejecuta la rotación automáticamente.

Requisitos previos

Infraestructura

  • Servidor Vault (v1.13+) con alta disponibilidad (Raft o Consul).
  • Acceso a un endpoint ACME público (ej. https://acme-v02.api.letsencrypt.org/directory) o a un CA interno que exponga la API ACME (ej. step-ca).
  • DNS interno que resuelva los nombres de los servicios (puede ser Bind, CoreDNS, o Route53).
  • Máquinas cliente con Bash 4+, curl, jq y openssl instalados.

Credenciales

Necesitarás:

  • Token de root o un token con policy acme_issuer para crear el emisor.
  • Token con policy cert_renew que permita write en acme/issue/*.

Configuración de Vault como emisor ACME

1. Habilitar el motor de secretos PKI

# En la consola de Vault
vault secrets enable -path=internal-pki pki
# Configuramos un máximo de 10 años (3650 días)
vault secrets tune -max-lease-ttl=87600h internal-pki

2. Generar la CA raíz interna

vault write -format=json internal-pki/root/generate/internal \
    common_name="MyInternal CA" \
    ttl=87600h > ca.json

Exportamos el certificado y la clave para el servidor ACME

jq -r ‘.data.certificate’ ca.json > /etc/vault.d/ca.crt jq -r ‘.data.private_key’ ca.json > /etc/vault.d/ca.key chmod 600 /etc/vault.d/ca.key

3. Configurar el endpoint ACME en Vault

Vault incluye un plugin acme a partir de la versión 1.12. Lo habilitamos y lo configuramos:

# Habilitar el plugin
vault secrets enable -path=acme acme

Registrar el plugin (si no está en el binario)

vault write sys/plugins/catalog/acme
sha_256=$(sha256sum /usr/local/lib/vault/plugins/vault-plugin-acme | cut -d’ ’ -f1)
command=“vault-plugin-acme”

Configurar el emisor

vault write acme/config/issuer/internal
ca_bundle=@/etc/vault.d/ca.crt
ca_private_key=@/etc/vault.d/ca.key
name=“internal-ca”
ttl=“720h”

4. Definir políticas de emisión

# policy: acme_issuer.hcl
path "acme/issue/*" {
  capabilities = ["create", "read"]
}

policy: cert_renew.hcl

path “acme/issue/internal/*” { capabilities = [“create”, “read”] }

Aplicamos las políticas:

vault policy write acme_issuer acme_issuer.hcl
vault policy write cert_renew cert_renew.hcl

Script Bash para solicitar y desplegar certificados

2.1. Estructura del script

El script renew_cert.sh realiza:

  • Generación de una clave RSA/ECDSA.
  • Creación de un CSR con los SAN necesarios.
  • Solicitud al endpoint ACME de Vault.
  • Almacenamiento del certificado y clave en /etc/ssl/private y recarga del servicio.

2.2. Código completo

#!/usr/bin/env bash
set -euo pipefail

#---- Configuración ------------------------------------------------- VAULT_ADDR=“https://vault.internal:8200” VAULT_TOKEN=“s.xxxxxxx” # token con policy cert_renew ACME_ISSUER=“internal” DOMAIN=”${1:-myservice.internal}” # argumento: nombre DNS CERT_DIR=“/etc/ssl/private/${DOMAIN}” KEY_ALGO=“rsa” # o “ecdsa” RSA_BITS=4096 ECDSA_CURVE=“prime256v1” #-------------------------------------------------------------------

mkdir -p ”${CERT_DIR}” cd ”${CERT_DIR}”

1) Generar clave privada

if [[ ”${KEY_ALGO}” == “rsa” ]]; then openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:${RSA_BITS} -out priv.key else openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:${ECDSA_CURVE} -out priv.key fi chmod 600 priv.key

2) Crear CSR (incluye SAN)

cat > csr.conf <<EOF [ req ] distinguished_name = req_distinguished_name req_extensions = v3_req prompt = no

[ req_distinguished_name ] CN = ${DOMAIN}

[ v3_req ] subjectAltName = @alt_names

[ alt_names ] DNS.1 = ${DOMAIN} DNS.2 = ${DOMAIN//./-}.svc.cluster.local # ejemplo para k8s EOF

openssl req -new -key priv.key -config csr.conf -out request.csr

3) Solicitar certificado vía ACME de Vault

RESPONSE=$(curl -s —header “X-Vault-Token: ${VAULT_TOKEN}”
—request POST
—data @- ”${VAULT_ADDR}/v1/acme/issue/${ACME_ISSUER}/${DOMAIN}” <<EOF { “csr”: ”$(base64 -w0 request.csr)” } EOF )

4) Parsear respuesta

CERT=$(echo ”${RESPONSE}” | jq -r ‘.data.certificate’) CHAIN=$(echo ”${RESPONSE}” | jq -r ‘.data.issuer_certificate’) FULLCHAIN=”${CERT}\n${CHAIN}”

Guardar

echo -e ”${CERT}” > cert.crt echo -e ”${FULLCHAIN}” > fullchain.crt

echo ”✅ Certificado emitido para ${DOMAIN} y guardado en ${CERT_DIR}”

2.3. Integración con systemd

Para que la rotación sea automática, creamos un timer que ejecute el script cada 30 días.

# /etc/systemd/system/renew-${DOMAIN}.service
[Unit]
Description=Renovar certificado TLS para ${DOMAIN}
After=network-online.target
Wants=network-online.target

[Service] Type=oneshot ExecStart=/usr/local/bin/renew_cert.sh ${DOMAIN} Environment=VAULT_ADDR=https://vault.internal:8200 Environment=VAULT_TOKEN=s.xxxxxxx

# /etc/systemd/system/renew-${DOMAIN}.timer
[Unit]
Description=Timer para renovar certificado TLS cada 30d

[Timer]
OnCalendar=*-*-1/30 *:00:00
Persistent=true

[Install]
WantedBy=timers.target

Habilitamos el timer:

systemctl daemon-reload
systemctl enable --now renew-${DOMAIN}.timer

Despliegue en entornos híbridos

On‑prem

En los servidores físicos o VMs, el script se ejecuta directamente y la recarga del servicio se hace con systemctl reload nginx (o el daemon correspondiente). El archivo de certificado se coloca en la ruta esperada por el servicio.

Cloud (Ej. AWS EC2 + EKS)

Para contenedores, se monta un emptyDir o un secret que el script actualiza. En Kubernetes, podemos usar un Init Container que invoque el mismo script y copie los artefactos a /etc/ssl/certs. Alternativamente, el script puede publicar el certificado como Secret usando kubectl create secret tls con la opción --dry-run=client -o yaml | kubectl apply -f -.

Sección de Troubleshooting

Errores comunes

  • 400 Bad Request – csr missing: El CSR no está codificado en Base64 o el campo csr tiene nombre incorrecto. Verifique la salida de base64 -w0 request.csr.
  • 403 Forbidden – policy violation: El token usado no tiene la policy cert_renew. Revise vault token lookup y las policies asociadas.
  • 500 Internal Server Error – unknown issuer: El nombre del emisor (p.e. internal) no coincide con la ruta configurada en acme/config/issuer. Use vault read acme/config/issuers para listar.
  • Timeout al contactar Vault: Problemas de TLS o firewall. Asegúrese de que VAULT_ADDR sea alcanzable y que el certificado de Vault sea confiable en el host cliente.
  • El certificado no contiene los SAN esperados: Revise el archivo csr.conf y asegúrese de que la sección subjectAltName liste todos los nombres.

Comandos de diagnóstico

# Ver token y policies
vault token lookup -format=json ${VAULT_TOKEN} | jq .data.policies

Ver la configuración del emisor ACME

vault read acme/config/issuer/internal

Probar la solicitud manualmente (sin script)

curl -s —header “X-Vault-Token: ${VAULT_TOKEN}”
—request POST
—data ’{“csr”:”’”$(base64 -w0 request.csr)”’”}’
${VAULT_ADDR}/v1/acme/issue/internal/${DOMAIN}

Conclusión

Integrar ACME dentro de HashiCorp Vault y automatizar la emisión con Bash permite mantener certificados TLS internos siempre actualizados, sin intervención manual y con trazabilidad de auditoría centralizada. La solución funciona sin cambios estructurales tanto en datacenters on‑prem como en entornos cloud, y se adapta fácilmente a Kubernetes mediante secretos o init containers.

Recuerda siempre:

  • Rotar los tokens de Vault periódicamente.
  • Mantener una copia de la CA raíz fuera del clúster (por ejemplo, en un HSM).
  • Monitorizar los logs de Vault (/var/log/vault.log) y los timers de systemd para detectar fallos tempranos.

Con esta arquitectura tu organización reduce el riesgo de expiración de certificados, mejora la postura de seguridad y simplifica la gestión operativa.

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal