Rotación de Claves es el proceso de renovación periódica de claves criptográficas para mantener la seguridad, reducir el riesgo de compromiso y cumplir con las mejores prácticas de seguridad.

¿Qué es la Rotación de Claves?

La rotación de claves es una práctica de seguridad que consiste en reemplazar regularmente las claves criptográficas utilizadas para cifrar y descifrar datos, autenticar usuarios y proteger comunicaciones.

Importancia de la Rotación

Reducción de Riesgos

  • Compromiso Limitado: Limita el impacto de claves comprometidas
  • Ventana de Exposición: Reduce la ventana de exposición
  • Ataques: Dificulta ataques de fuerza bruta
  • Seguridad: Mantiene la seguridad a largo plazo

Cumplimiento Normativo

  • Estándares: Cumplimiento de estándares de seguridad
  • Regulaciones: Cumplimiento de regulaciones
  • Auditorías: Preparación para auditorías
  • Certificaciones: Mantenimiento de certificaciones

Mejores Prácticas

  • Industria: Estándares de la industria
  • Recomendaciones: Recomendaciones de expertos
  • Seguridad: Prácticas de seguridad robustas
  • Gestión: Gestión proactiva de riesgos

Tipos de Rotación

Rotación Programada

  • Cronograma: Rotación según cronograma fijo
  • Periódica: Rotación regular (diaria, semanal, mensual)
  • Automática: Rotación automática
  • Predecible: Fácil de planificar

Rotación por Eventos

  • Compromiso: Rotación tras compromiso sospechado
  • Personal: Rotación tras cambio de personal
  • Sistema: Rotación tras cambios en el sistema
  • Emergencia: Rotación de emergencia

Rotación Gradual

  • Transición: Transición gradual entre claves
  • Coexistencia: Coexistencia temporal de claves
  • Migración: Migración gradual de datos
  • Compatibilidad: Mantenimiento de compatibilidad

Estrategias de Rotación

Rotación Simple

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

import datetime
import secrets
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

class SimpleKeyRotation:
    def __init__(self, rotation_interval_days=90):
        self.rotation_interval = datetime.timedelta(days=rotation_interval_days)
        self.current_key = None
        self.key_history = []
        self.last_rotation = None
    
    def generate_new_key(self, key_size=2048):
        """Generar nueva clave"""
        private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=key_size
        )
        return private_key
    
    def should_rotate(self):
        """Verificar si es necesario rotar la clave"""
        if self.last_rotation is None:
            return True
        
        return datetime.datetime.now() - self.last_rotation > self.rotation_interval
    
    def rotate_key(self):
        """Rotar la clave"""
        if not self.should_rotate():
            return False
        
        # Generar nueva clave
        new_key = self.generate_new_key()
        
        # Guardar clave anterior en historial
        if self.current_key is not None:
            self.key_history.append({
                'key': self.current_key,
                'created': self.last_rotation,
                'retired': datetime.datetime.now()
            })
        
        # Actualizar clave actual
        self.current_key = new_key
        self.last_rotation = datetime.datetime.now()
        
        return True

# Ejemplo de uso
key_rotation = SimpleKeyRotation(rotation_interval_days=30)
if key_rotation.should_rotate():
    key_rotation.rotate_key()

Rotación con Migración de Datos

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

class DataMigrationKeyRotation:
    def __init__(self, encryption_service):
        self.encryption_service = encryption_service
        self.old_key = None
        self.new_key = None
        self.migration_status = "idle"
    
    def start_rotation(self):
        """Iniciar proceso de rotación"""
        # Generar nueva clave
        self.new_key = self.generate_new_key()
        
        # Mantener clave anterior
        self.old_key = self.encryption_service.get_current_key()
        
        # Cambiar estado
        self.migration_status = "migrating"
        
        return True
    
    def migrate_data(self, encrypted_data):
        """Migrar datos cifrados"""
        if self.migration_status != "migrating":
            raise ValueError("Rotación no iniciada")
        
        # Descifrar con clave anterior
        decrypted_data = self.encryption_service.decrypt(
            encrypted_data, 
            self.old_key
        )
        
        # Cifrar con nueva clave
        new_encrypted_data = self.encryption_service.encrypt(
            decrypted_data, 
            self.new_key
        )
        
        return new_encrypted_data
    
    def complete_rotation(self):
        """Completar rotación"""
        if self.migration_status != "migrating":
            raise ValueError("Migración no en progreso")
        
        # Actualizar servicio de cifrado
        self.encryption_service.set_current_key(self.new_key)
        
        # Limpiar clave anterior
        self.old_key = None
        self.migration_status = "completed"
        
        return True

# Ejemplo de uso
class EncryptionService:
    def __init__(self):
        self.current_key = None
    
    def get_current_key(self):
        return self.current_key
    
    def set_current_key(self, key):
        self.current_key = key
    
    def encrypt(self, data, key):
        # Implementar cifrado
        return f"encrypted_{data}"
    
    def decrypt(self, encrypted_data, key):
        # Implementar descifrado
        return encrypted_data.replace("encrypted_", "")

encryption_service = EncryptionService()
rotation = DataMigrationKeyRotation(encryption_service)

Automatización de Rotación

Rotación Automática

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

import schedule
import time
import logging
from datetime import datetime

class AutomatedKeyRotation:
    def __init__(self, key_manager, rotation_interval_hours=24):
        self.key_manager = key_manager
        self.rotation_interval = rotation_interval_hours
        self.logger = logging.getLogger(__name__)
    
    def setup_schedule(self):
        """Configurar horario de rotación"""
        schedule.every(self.rotation_interval).hours.do(self.rotate_keys)
        self.logger.info(f"Rotación programada cada {self.rotation_interval} horas")
    
    def rotate_keys(self):
        """Rotar claves automáticamente"""
        try:
            self.logger.info("Iniciando rotación automática de claves")
            
            # Obtener claves que necesitan rotación
            keys_to_rotate = self.key_manager.get_keys_for_rotation()
            
            for key_id in keys_to_rotate:
                self.key_manager.rotate_key(key_id)
                self.logger.info(f"Clave {key_id} rotada exitosamente")
            
            self.logger.info("Rotación automática completada")
            
        except Exception as e:
            self.logger.error(f"Error en rotación automática: {e}")
    
    def start_scheduler(self):
        """Iniciar programador"""
        self.setup_schedule()
        
        while True:
            schedule.run_pending()
            time.sleep(60)  # Verificar cada minuto

# Ejemplo de uso
class KeyManager:
    def __init__(self):
        self.keys = {}
    
    def get_keys_for_rotation(self):
        """Obtener claves que necesitan rotación"""
        keys_to_rotate = []
        for key_id, key_info in self.keys.items():
            if self.should_rotate_key(key_info):
                keys_to_rotate.append(key_id)
        return keys_to_rotate
    
    def should_rotate_key(self, key_info):
        """Verificar si una clave necesita rotación"""
        # Implementar lógica de rotación
        return True
    
    def rotate_key(self, key_id):
        """Rotar una clave específica"""
        # Implementar rotación de clave
        pass

key_manager = KeyManager()
automated_rotation = AutomatedKeyRotation(key_manager)
# automated_rotation.start_scheduler()  # Ejecutar en hilo separado

Rotación por Eventos

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

class EventDrivenKeyRotation:
    def __init__(self, key_manager):
        self.key_manager = key_manager
        self.event_handlers = {
            'key_compromise': self.handle_compromise,
            'personnel_change': self.handle_personnel_change,
            'system_change': self.handle_system_change,
            'emergency': self.handle_emergency
        }
    
    def handle_event(self, event_type, event_data):
        """Manejar evento de rotación"""
        if event_type in self.event_handlers:
            self.event_handlers[event_type](event_data)
        else:
            raise ValueError(f"Tipo de evento no soportado: {event_type}")
    
    def handle_compromise(self, event_data):
        """Manejar compromiso de clave"""
        key_id = event_data.get('key_id')
        if key_id:
            self.key_manager.rotate_key_immediately(key_id)
            self.key_manager.revoke_key(key_id)
    
    def handle_personnel_change(self, event_data):
        """Manejar cambio de personal"""
        user_id = event_data.get('user_id')
        if user_id:
            self.key_manager.rotate_user_keys(user_id)
    
    def handle_system_change(self, event_data):
        """Manejar cambio de sistema"""
        system_id = event_data.get('system_id')
        if system_id:
            self.key_manager.rotate_system_keys(system_id)
    
    def handle_emergency(self, event_data):
        """Manejar rotación de emergencia"""
        self.key_manager.rotate_all_keys()

# Ejemplo de uso
event_rotation = EventDrivenKeyRotation(key_manager)
event_rotation.handle_event('key_compromise', {'key_id': 'key_123'})

Mejores Prácticas

Frecuencia de Rotación

  • Claves de Sesión: Rotación frecuente (diaria/semanal)
  • Claves de Cifrado: Rotación regular (mensual/trimestral)
  • Claves de Firma: Rotación menos frecuente (anual)
  • Claves de Raíz: Rotación muy poco frecuente

Gestión del Ciclo de Vida

  • Generación: Generación segura de claves
  • Distribución: Distribución segura
  • Uso: Uso controlado
  • Rotación: Rotación programada
  • Revocación: Revocación cuando sea necesario
  • Destrucción: Destrucción segura

Monitoreo y Auditoría

  • Logging: Registro de todas las operaciones
  • Monitoreo: Monitoreo continuo
  • Alertas: Alertas por fallos
  • Auditoría: Auditoría regular

Herramientas de Rotación

AWS KMS

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import boto3
from botocore.exceptions import ClientError

class AWSKMSKeyRotation:
    def __init__(self, region_name='us-east-1'):
        self.kms_client = boto3.client('kms', region_name=region_name)
    
    def enable_automatic_rotation(self, key_id, rotation_period_days=365):
        """Habilitar rotación automática"""
        try:
            response = self.kms_client.enable_key_rotation(
                KeyId=key_id
            )
            return response
        except ClientError as e:
            print(f"Error habilitando rotación: {e}")
            return None
    
    def rotate_key(self, key_id):
        """Rotar clave manualmente"""
        try:
            response = self.kms_client.create_key(
                Description=f"Rotated key for {key_id}",
                KeyUsage='ENCRYPT_DECRYPT'
            )
            return response['KeyMetadata']['KeyId']
        except ClientError as e:
            print(f"Error rotando clave: {e}")
            return None

# Ejemplo de uso
kms_rotation = AWSKMSKeyRotation()
kms_rotation.enable_automatic_rotation('alias/my-key')

HashiCorp Vault

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import hvac

class VaultKeyRotation:
    def __init__(self, vault_url, token):
        self.client = hvac.Client(url=vault_url, token=token)
    
    def rotate_transit_key(self, key_name):
        """Rotar clave de tránsito"""
        try:
            response = self.client.secrets.transit.rotate_key(
                name=key_name
            )
            return response
        except Exception as e:
            print(f"Error rotando clave: {e}")
            return None
    
    def rekey_transit_key(self, key_name, new_key_name):
        """Rekey clave de tránsito"""
        try:
            response = self.client.secrets.transit.rekey(
                name=key_name,
                new_name=new_key_name
            )
            return response
        except Exception as e:
            print(f"Error rekeying clave: {e}")
            return None

# Ejemplo de uso
vault_rotation = VaultKeyRotation('http://localhost:8200', 'my-token')
vault_rotation.rotate_transit_key('my-encryption-key')

Conceptos Relacionados

  • PKI - Infraestructura que gestiona rotación de claves
  • HSM - Dispositivo que facilita rotación de claves
  • Key Escrow - Sistema que complementa rotación de claves
  • RSA - Algoritmo que requiere rotación de claves
  • AES - Algoritmo que requiere rotación de claves
  • CISO - Rol que supervisa rotación de claves
  • Ciberseguridad General - Disciplina que incluye rotación de claves
  • Brechas de seguridad - Incidentes que requieren rotación de claves
  • Vectores de ataque - Ataques que requieren rotación de claves
  • Incident Response - Proceso que incluye rotación de claves
  • SIEM - Sistema que monitorea rotación de claves
  • SOAR - Automatización que gestiona rotación de claves
  • EDR - Herramienta que protege rotación de claves
  • Firewall - Dispositivo que complementa rotación de claves
  • VPN - Conexión que requiere rotación de claves
  • Dashboards - Visualización de métricas rotación de claves
  • Registros - Logs de operaciones rotación de claves

Referencias