Admin-Sistemas ·

Automatización con Python y Ansible: gestión segura de claves SSH en entornos híbridos

Introducción

En entornos híbridos, donde coexisten servidores físicos on‑premises y máquinas virtuales en la nube, la gestión de claves SSH se vuelve un punto crítico de seguridad y operatividad. La rotación periódica de claves evita la reutilización indebida y reduce la superficie de ataque, mientras que la distribución controlada garantiza que sólo los usuarios y procesos autorizados tengan acceso.

Este artículo muestra cómo combinar Python (para generación y cálculo de huellas) y Ansible (para orquestación) y lograr un flujo completo de generación → rotación → distribución segura. Cada paso incluye comandos reales, fragmentos de configuración y la lógica detrás de cada decisión.

1. Generación automática de pares de claves SSH con Python

1.1. Por qué usar Python

Python permite crear scripts portables que no dependen de la presencia de ssh-keygen en el nodo de control. Además, con la biblioteca cryptography podemos definir el algoritmo (RSA, ECDSA, Ed25519) y el tamaño de clave de forma declarativa.

1.2. Instalación de dependencias

python3 -m venv venv
source venv/bin/activate
pip install cryptography

1.3. Script de generación

#!/usr/bin/env python3
import os
import base64
from pathlib import Path
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ed25519

def generate_keypair(key_name: str, out_dir: Path): # Generamos una clave Ed25519 (más segura y ligera que RSA) private_key = ed25519.Ed25519PrivateKey.generate() public_key = private_key.public_key()

# Serializamos la clave privada en formato OpenSSH
priv_bytes = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.OpenSSH,
    encryption_algorithm=serialization.BestAvailableEncryption(b\"$(openssl rand -base64 32)\"),  # password aleatorio
)
# Serializamos la clave pública en formato autorizado
pub_bytes = public_key.public_bytes(
    encoding=serialization.Encoding.OpenSSH,
    format=serialization.PublicFormat.OpenSSH,
)

# Guardamos los archivos
priv_path = out_dir / f\"{key_name}\"
pub_path = out_dir / f\"{key_name}.pub\"

priv_path.write_bytes(priv_bytes)
pub_path.write_bytes(pub_bytes)

# Restricciones de permisos
os.chmod(priv_path, 0o600)
os.chmod(pub_path, 0o644)

return priv_path, pub_path

if name == “main”: import argparse parser = argparse.ArgumentParser(description=“Genera pares de claves SSH Ed25519.”) parser.add_argument(“—name”, required=True, help=“Nombre base del par de claves”) parser.add_argument(“—out”, default=”./keys”, help=“Directorio de salida”) args = parser.parse_args()

out_dir = Path(args.out).expanduser().resolve()
out_dir.mkdir(parents=True, exist_ok=True)

priv, pub = generate_keypair(args.name, out_dir)
print(f\"Clave privada: {priv}\")
print(f\"Clave pública : {pub}\")</code></pre>

1.4. Explicación de los pasos críticos

  • Ed25519: algoritmo moderno, 256‑bits, resistente a ataques de factorización y más rápido que RSA.
  • Encriptación de la clave privada: se usa BestAvailableEncryption con una contraseña aleatoria generada por OpenSSL; la contraseña se almacena temporalmente en un vault de Ansible (ver sección 3).
  • Permisos: 600 para la privada (acceso exclusivo del propietario) y 644 para la pública.

2. Orquestación de la rotación con Ansible

2.1. Arquitectura del playbook

Dividimos el flujo en tres roles:

  1. ssh_keygen: ejecuta el script Python y coloca las claves en files/.
  2. ssh_distribute: copia la clave pública a los hosts objetivo y actualiza authorized_keys.
  3. ssh_cleanup: revoca claves antiguas y elimina archivos temporales.

2.2. Inventario híbrido

# inventory.ini
[onprem]
srv01.example.com
srv02.example.com

[cloud] ec2-3-12-45-67.compute-1.amazonaws.com ec2-54-210-12-34.compute-1.amazonaws.com

[all:vars] ansible_user=admin ansible_ssh_private_key_file=~/.ssh/id_rsa_ansible

2.3. Playbook principal

--- 
- name: Rotación automática de claves SSH
  hosts: all
  become: true
  vars:
    key_name: "deploy_{{ inventory_hostname }}"
    key_dir: "/tmp/ssh_keys"
  roles:
    - role: ssh_keygen
    - role: ssh_distribute
    - role: ssh_cleanup

2.4. Detalle del rol ssh_keygen

# roles/ssh_keygen/tasks/main.yml
- name: Crear directorio temporal
  file:
    path: "{{ key_dir }}"
    state: directory
    mode: '0700'
  • name: Ejecutar script Python de generación command: > {{ playbook_dir }}/scripts/gen_ssh_key.py —name {{ key_name }} —out {{ key_dir }} args: creates: ”{{ key_dir }}/{{ key_name }}”

  • name: Registrar rutas de las claves generadas set_fact: private_key_path: ”{{ key_dir }}/{{ key_name }}” public_key_path: ”{{ key_dir }}/{{ key_name }}.pub”

2.5. Detalle del rol ssh_distribute

# roles/ssh_distribute/tasks/main.yml
- name: Guardar la clave pública en el host remoto
  authorized_key:
    user: "{{ ansible_user }}"
    state: present
    key: "{{ lookup('file', public_key_path) }}"
    exclusive: false   # no elimina otras claves válidas
  • name: Copiar clave privada cifrada al vault de Ansible delegate_to: localhost ansible.builtin.slurp: src: ”{{ private_key_path }}” register: private_key_content

  • name: Almacenar la clave privada en el vault (encriptado) ansible.builtin.copy: dest: ”{{ playbook_dir }}/vault/{{ inventory_hostname }}_id_ed25519.enc” content: ”{{ private_key_content.content | b64decode }}” mode: ‘0600’ when: private_key_content is defined

2.6. Detalle del rol ssh_cleanup

# roles/ssh_cleanup/tasks/main.yml
- name: Eliminar archivo de clave privada del nodo de control
  file:
    path: "{{ private_key_path }}"
    state: absent
  delegate_to: localhost
  • name: Eliminar directorio temporal file: path: ”{{ key_dir }}” state: absent delegate_to: localhost

3. Seguridad en la distribución: uso de Ansible Vault y SSH Agent

3.1. Por qué combinar Vault y ssh‑agent

La clave privada nunca debe viajar sin cifrar. Ansible Vault garantiza que el archivo .enc está encriptado con una contraseña fuerte. Para que los procesos automáticos (por ejemplo, pipelines CI/CD) la usen, cargamos la clave en ssh‑agent en tiempo de ejecución.

3.2. Creación del vault

# Crear un vault llamado secrets.yml
ansible-vault create vault/secrets.yml
# Dentro, guardamos:
private_key_password: "c0ntr4s3n4SegUr0!"

3.3. Desencriptado y carga en ssh‑agent

#!/bin/bash
# load_key.sh – ejecutado por CI antes de cualquier playbook
VAULT_PASS=$(ansible-vault view --vault-password-file .vault_pass vault/secrets.yml | grep private_key_password | awk '{print $2}')
ENCRYPTED_KEY="vault/{{ inventory_hostname }}_id_ed25519.enc"

Desencriptar temporalmente

ansible-vault view —vault-password-file .vault_pass “$ENCRYPTED_KEY” > /tmp/id_ed25519

chmod 600 /tmp/id_ed25519 ssh-add /tmp/id_ed25519 rm -f /tmp/id_ed25519

3.4. Buenas prácticas

  • Limitar el alcance del vault a usuarios CI/CD mediante ACL de Git.
  • Rotar la contraseña del vault cada 90 días usando ansible-vault rekey.
  • Configurar ssh-agent con timeout corto (por ejemplo, SSH_AUTH_SOCK 10 min).

4. Implementación en entornos híbridos (on‑prem y cloud)

4.1. Diferencias de acceso

Los servidores on‑prem suelen estar detrás de VPN o bastión, mientras que en la nube se accede mediante bastiones bastion hosts o mediante puertos restringidos a IPs de gestión. Ansible permite especificar ansible_ssh_common_args para cada grupo.

# inventory.ini (continuación)
[onprem:vars]
ansible_ssh_common_args='-o ProxyCommand="ssh -W %h:%p bastion.example.com"'

[cloud:vars]
ansible_ssh_common_args='-o StrictHostKeyChecking=no'

4.2. Uso de dynamic inventory para cloud

En AWS, aws_ec2 plugin genera el inventario automáticamente. Basta con agregar al ansible.cfg:

[defaults]
inventory = ./inventory.ini, ./aws_ec2.yml

4.3. Validación post‑rotación

Después de distribuir las claves, verificamos que sólo la nueva clave está presente en authorized_keys y que la antigua ha sido marcada como revocada.

- name: Validar que la clave nueva está presente
  become: true
  lineinfile:
    path: "/home/{{ ansible_user }}/.ssh/authorized_keys"
    regexp: "{{ lookup('file', public_key_path) | regex_escape }}"
    state: present
  • name: Eliminar claves antiguas marcadas en el vault become: true shell: | grep -v -f {{ playbook_dir }}/vault/old_keys.txt /home/{{ ansible_user }}/.ssh/authorized_keys > /tmp/ak.tmp &&
    mv /tmp/ak.tmp /home/{{ ansible_user }}/.ssh/authorized_keys

5. Troubleshooting y errores comunes

5.1. “Permission denied (publickey)” al ejecutar el playbook

  • Causa: La clave privada no está cargada en ssh-agent o el agente no tiene la clave correcta.
  • Solución: Ejecutar ssh-add -l para listar claves cargadas; si falta, usar load_key.sh o importar manualmente.

5.2. Ansible falla al leer authorized_keys

  • Causa: Permisos de .ssh o authorized_keys demasiado abiertos (por ejemplo, 777).
  • Solución: Asegurarse de que la carpeta tenga 0700 y el archivo 0644. Ansible puede corregirlo con file module antes de añadir la clave.

5.3. El script Python genera una clave sin contraseña

  • Causa: Variable de entorno $(openssl rand -base64 32) no se expande dentro de Python.
  • Solución: Reemplazar por os.urandom(32) dentro del script o pasar la contraseña como argumento.

5.4. Errores de “Host key verification failed” en hosts cloud

  • Causa: El host nunca se ha añadido al known_hosts del controlador.
  • Solución: Añadir ansible_ssh_common_args='-o StrictHostKeyChecking=no' temporalmente o ejecutar ssh-keyscan antes del playbook.

5.5. Clave pública no se refleja en authorized_keys

  • Causa: Variable public_key_path no está disponible en el host remoto porque el task se ejecutó con delegate_to: localhost sin registrar.
  • Solución: Asegurarse de usar set_fact después del task de generación y que el scope sea *host* (no *local*).

Conclusión

Automatizar la generación, rotación y distribución de claves SSH con Python y Ansible brinda seguridad, consistencia y velocidad en entornos híbridos. La combinación de un script Python fiable, roles Ansible bien estructurados y el uso correcto de Ansible Vault/ssh‑agent protege tanto los activos on‑prem como los recursos en la nube.

Implementar este flujo permite cumplir con políticas de cumplimiento (PCI‑DSS, ISO 27001) que exigen rotación periódica de credenciales, al mismo tiempo que elimina el error humano típico de la gestión manual. Ajusta los tamaños de clave, los intervalos de rotación y la integración con tu pipeline CI/CD para obtener una solución a prueba de futuro.