← volver

Implementación paso a paso de una PKI interna con cfssl

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

Introducción

En entornos híbridos, donde parte de la infraestructura está on‑prem y otra en la nube, contar con una PKI (Public Key Infrastructure) interna permite emitir y gestionar certificados TLS de forma centralizada, evitar dependencias externas y cumplir con requisitos de seguridad y auditoría.

Este artículo muestra cómo desplegar cfssl (CFSSL), la herramienta de Cloudflare, para:

  • Crear una autoridad certificadora raíz (Root CA) y una intermedia (Intermediate CA).
  • Automatizar la emisión de certificados para servidores y usuarios.
  • Implementar rotación periódica y revocación mediante CRL y OCSP.
  • Integrar la solución en pipelines CI/CD y en orquestadores como Kubernetes y Terraform.

1. Preparación del entorno

1.1 Requisitos de software

En ambos entornos (on‑prem y cloud) necesitamos:

# En Ubuntu/Debian
sudo apt-get update
sudo apt-get install -y curl jq git

Instalar cfssl y cfssljson (última versión)

curl -s -L -o /usr/local/bin/cfssl https://github.com/cloudflare/cfssl/releases/download/v1.6.3/cfssl_1.6.3_linux_amd64 curl -s -L -o /usr/local/bin/cfssljson https://github.com/cloudflare/cfssl/releases/download/v1.6.3/cfssljson_1.6.3_linux_amd64 chmod +x /usr/local/bin/cfssl /usr/local/bin/cfssljson

1.2 Estructura de directorios

Una buena práctica es separar los artefactos por tipo:

mkdir -p /opt/pki/{root,intermediate,certs,crl,ocsp}
chmod 700 /opt/pki

1.3 Variables de entorno

export PKI_ROOT=/opt/pki/root
export PKI_INTER=/opt/pki/intermediate
export PKI_CERTS=$PKI_ROOT/../certs
export PKI_CRL=$PKI_ROOT/../crl
export PKI_OCSP=$PKI_ROOT/../ocsp

2. Creación de la autoridad certificadora

2.1 Generar la Root CA

Definimos el perfil ca-config.json y la petición ca-csr.json:

# ca-config.json
{
  "signing": {
    "default": {
      "expiry": "87600h",   // 10 años
      "usages": ["signing", "key encipherment", "cert sign", "crl sign"]
    },
    "profiles": {
      "root": {
        "expiry": "87600h",
        "usages": ["signing", "cert sign", "crl sign"]
      }
    }
  }
}
# ca-csr.json
{
  "CN": "MyCompany Root CA",
  "key": {
    "algo": "rsa",
    "size": 4096
  },
  "hosts": [],
  "ca": {
    "expiry": "87600h"
  }
}

Generamos la clave y el certificado:

cd $PKI_ROOT
cfssl gencert -initca ca-csr.json | cfssljson -bare root
# Resultado: root-key.pem, root.pem

Para mayor seguridad, almacenamos root-key.pem en un HSM o en un vault (ej. HashiCorp Vault) y lo marcamos como chmod 400.

2.2 Generar la Intermediate CA

La Intermediate permite firmar certificados operacionales sin exponer la clave raíz.

# intermediate-ca-csr.json
{
  "CN": "MyCompany Intermediate CA",
  "key": { "algo": "rsa", "size": 4096 },
  "ca": { "expiry": "43800h" }   // 5 años
}

Crear la solicitud y firmarla con la Root:

cd $PKI_INTER
cfssl gencert -initca intermediate-ca-csr.json | cfssljson -bare intermediate
# Firma con la Root
cfssl sign -ca=$PKI_ROOT/root.pem -ca-key=$PKI_ROOT/root-key.pem \
  -config=$PKI_ROOT/ca-config.json -profile=root \
  intermediate.csr | cfssljson -bare intermediate

Ahora disponemos de intermediate-key.pem y intermediate.pem.

3. Automatización de emisión de certificados

3.1 Definir perfiles de certificado

Los perfiles describen usos y tiempos de expiración. Guardamos en ca-config.json bajo profiles:

"profiles": {
  "server": {
    "expiry": "8760h",          // 1 año
    "usages": ["signing", "key encipherment", "server auth"]
  },
  "client": {
    "expiry": "4380h",          // 6 meses
    "usages": ["signing", "key encipherment", "client auth"]
  }
}

3.2 Plantilla de solicitud (CSR) genérica

# csr-template.json
{
  "hosts": [],
  "key": { "algo": "rsa", "size": 2048 },
  "CN": ""
}

3.3 Script de emisión (bash)

El siguiente script puede ser llamado desde CI/CD o por usuarios internos.

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

TYPE=$1 # server|client COMMON_NAME=$2 HOSTS=${3:-""} # lista separada por comas

Crear CSR temporal

cat > /tmp/${COMMON_NAME}.json <<EOF { “CN”: ”${COMMON_NAME}”, “hosts”: [$(echo ”${HOSTS}” | jq -R ‘split(”,”) | .[] | @json’ | paste -sd ”,” -)], “key”: { “algo”: “rsa”, “size”: 2048 } } EOF

Emitir certificado con la Intermediate

cfssl gencert -ca=$PKI_INTER/intermediate.pem
-ca-key=$PKI_INTER/intermediate-key.pem
-config=$PKI_INTER/ca-config.json
-profile=${TYPE} /tmp/${COMMON_NAME}.json | cfssljson -bare ${COMMON_NAME}

Mover a ubicación final

mv ${COMMON_NAME}.pem $PKI_CERTS/ mv ${COMMON_NAME}-key.pem $PKI_CERTS/ chmod 600 $PKI_CERTS/${COMMON_NAME}-key.pem chmod 644 $PKI_CERTS/${COMMON_NAME}.pem

Ejemplo de uso:

# Emitir certificado para un API en Kubernetes
./issue-cert.sh server api.mycompany.internal "api.mycompany.internal,10.0.0.5"

3.4 Integración con Kubernetes (cert‑manager)

Si la infraestructura usa Kubernetes, podemos registrar cfssl como Issuer externo a través de ExternalIssuer o usar cert-manager con un CAProvider que apunte al endpoint HTTP de cfssl.

apiVersion: cert-manager.io/v1
kind: Issuer
metadata:
  name: internal-cfssl-issuer
spec:
  ca:
    secretName: cfssl-intermediate-secret

4. Rotación y revocación de certificados

4.1 Rotación programada de la Intermediate

Se recomienda rotar la Intermediate cada 2‑3 años. El proceso:

  1. Crear una nueva Intermediate siguiendo el apartado 2.2.
  2. Publicar su certificado en /etc/ssl/certs/ca-bundle.crt de todos los nodos.
  3. Re‑emitir certificados usando la nueva Intermediate (script anterior).
  4. Mantener la anterior durante al menos 1 año para permitir la validación de certificados ya emitidos.

4.2 Generación y publicación de CRL

Para revocar, generate una lista de revocación (CRL) y expórtala vía HTTP o S3.

# revocar un certificado
cfssl revokecert -ca=$PKI_INTER/intermediate.pem \
  -ca-key=$PKI_INTER/intermediate-key.pem \
  -serial=01B3F5A2E3D4

generar CRL

cfssl crl -ca=$PKI_INTER/intermediate.pem
-ca-key=$PKI_INTER/intermediate-key.pem
-db-config=db-config.json -profile=intermediate > $PKI_CRL/intermediate.crl

Configura los servidores (nginx, Apache, HAProxy) para que sirvan /crl/intermediate.crl y añade la URL al certificado (crlDistributionPoints) mediante un perfil personalizado.

4.3 OCSP opcional

Si se requiere respuesta en tiempo real, despliega cfssl ocspserve:

cfssl ocspserve -address=0.0.0.0:8888 \
  -ca=$PKI_INTER/intermediate.pem \
  -responder=$PKI_INTER/intermediate-key.pem \
  -db-config=db-config.json

Los clientes deben incluir AuthorityInfoAccess con la URL del OCSP.

4.4 Automatización con Terraform

Ejemplo de recurso para emitir certificados como parte de la infraestructura:

resource "null_resource" "cert_server" {
  provisioner "local-exec" {
    command = "./issue-cert.sh server ${var.hostname} ${join(\",\", var.dns_names)}"
  }
}

5. Troubleshooting y errores comunes

5.1 “cfssl: failed to sign request: unknown profile”

  • Causa: El perfil especificado no existe en ca-config.json o el archivo no está siendo referenciado.
  • Solución: Verificar la ruta del archivo en el comando -config y asegurar que el nombre del perfil coincide exactamente (mayúsculas/minúsculas).

5.2 Certificado no confía en el cliente

  • Causa: La cadena de confianza está incompleta (falta la Intermediate o la Root).
  • Solución: Concatenar intermediate.pem y root.pem en el archivo fullchain.pem y distribuirlo al cliente.

5.3 “permission denied” al leer claves privadas

  • Causa: Permisos demasiado restrictivos (por ejemplo, 600 en directorio sin acceso al usuario que ejecuta cfssl).
  • Solución: Ejecutar cfssl con el mismo usuario que posee las claves o usar sudo -u cfssl. Mantener chmod 400 para la clave raíz.

5.4 Revocación no se refleja en los servidores web

  • Causa: El servidor no está configurado para consultar la CRL/OCSP o la URL está mal escrita.
  • Solución: En nginx, añadir:
    ssl_crl /etc/ssl/crl/intermediate.crl;
    ssl_verify_client on;
    
    y reiniciar el servicio.

Conclusión

Implementar una PKI interna con cfssl brinda control total sobre el ciclo de vida de los certificados TLS en entornos híbridos, permite automatizar la emisión mediante scripts o pipelines, y facilita la rotación y revocación mediante CRL/OCSP. Siguiendo los pasos descritos—creación de autoridades raíz e intermedia, definición de perfiles, integración con Kubernetes y Terraform, y establecimiento de procesos de rotación—los sysadmins pueden garantizar una postura de seguridad robusta y cumplir con auditorías sin depender de terceros.

Recuerde siempre proteger la clave de la Root CA, monitorear la expiración de las Intermediates y validar que los clientes consumen la CRL/OCSP actualizada. Con estas buenas prácticas, su infraestructura híbrida mantendrá comunicaciones TLS confiables y resistentes a compromisos.

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