OP.AAC.5 Mecanismo de autenticación

Objetivo

Establecer los mecanismos de autenticación robustos y multinivel para el sistema Legit Health Plus, garantizando la verificación fidedigna de la identidad de usuarios y sistemas mediante métodos apropiados al nivel de riesgo, cumpliendo con ENS, MDR y estándares de ciberseguridad para dispositivos médicos.

Alcance

Este procedimiento aplica a:

• Autenticación de profesionales sanitarios y personal administrativo
• Autenticación de sistemas y servicios automatizados
• Autenticación para integraciones API y servicios externos
• Mecanismos de autenticación multifactor (MFA)
• Gestión de credenciales y secretos
• Autenticación federada y Single Sign-On (SSO)

Implementación en Legit Health Plus

Arquitectura de Autenticación

Niveles de Autenticación según Criticidad

Nivel	Contexto de Uso	Métodos Requeridos	Factores	Ejemplo
Nivel 1 - Básico	Acceso a información pública	Password robusto	1 factor	Documentación, estadísticas
Nivel 2 - Medio	Acceso a datos no críticos	Password + MFA	2 factores	Informes agregados
Nivel 3 - Alto	Acceso a datos de pacientes	Password + MFA + Contexto	2+ factores	Historiales clínicos
Nivel 4 - Crítico	Modificación de algoritmos IA	Certificado + MFA + Biometría	3 factores	Cambios en modelos diagnósticos
Nivel 5 - Máximo	Acceso administrativo total	Hardware token + Biometría + PIN	3+ factores	Root access, PKI management

Implementación de Autenticación Multifactor (MFA)

Configuración MFA por Rol

class MFAConfiguration:
    """
    Configuración de MFA para Legit Health Plus
    """

    MFA_REQUIREMENTS = {
        "HCP": {  # Healthcare Professionals
            "methods": ["TOTP", "SMS", "PUSH"],
            "required": True,
            "grace_period_days": 0,
            "remember_device_days": 7,
            "risk_based": True
        },
        "ITP": {  # IT Professionals
            "methods": ["HARDWARE_TOKEN", "TOTP"],
            "required": True,
            "grace_period_days": 0,
            "remember_device_days": 0,
            "risk_based": False
        },
        "ADMIN": {  # Administrators
            "methods": ["HARDWARE_TOKEN", "BIOMETRIC"],
            "required": True,
            "grace_period_days": 0,
            "remember_device_days": 0,
            "risk_based": False,
            "session_timeout_minutes": 15
        },
        "API": {  # API Clients
            "methods": ["CLIENT_CERTIFICATE"],
            "required": True,
            "mutual_tls": True
        }
    }

    def enforce_mfa(self, user_role: str, auth_context: dict) -> bool:
        """
        Determina si MFA es requerido basado en rol y contexto
        """
        config = self.MFA_REQUIREMENTS.get(user_role)

        if not config["required"]:
            return False

        # Evaluación basada en riesgo
        if config.get("risk_based"):
            risk_score = self.calculate_risk_score(auth_context)
            if risk_score > 0.7:  # Alto riesgo
                return True

        # Verificar dispositivo recordado
        if config.get("remember_device_days", 0) > 0:
            if self.is_device_remembered(auth_context["device_id"]):
                return False

        return True

    def calculate_risk_score(self, context: dict) -> float:
        """
        Calcula puntuación de riesgo basada en contexto
        """
        score = 0.0

        # Nueva ubicación geográfica
        if context.get("new_location"):
            score += 0.3

        # Dispositivo desconocido
        if not context.get("known_device"):
            score += 0.2

        # Hora inusual
        if self.is_unusual_hour(context.get("timestamp")):
            score += 0.2

        # Patrón de acceso anómalo
        if context.get("anomaly_detected"):
            score += 0.3

        return min(score, 1.0)

Políticas de Contraseñas

Requisitos de Complejidad

Parámetro	Usuario Estándar	Usuario Privilegiado	Administrador
Longitud mínima	12 caracteres	15 caracteres	20 caracteres
Mayúsculas	Mínimo 1	Mínimo 2	Mínimo 3
Minúsculas	Mínimo 1	Mínimo 2	Mínimo 3
Números	Mínimo 1	Mínimo 2	Mínimo 3
Caracteres especiales	Mínimo 1	Mínimo 2	Mínimo 3
Historial	Últimas 12	Últimas 24	Últimas 36
Expiración	90 días	60 días	30 días
Intentos fallidos	5	3	3
Bloqueo	30 minutos	60 minutos	Manual

Implementación de Políticas

import re
import hashlib
import secrets
from datetime import datetime, timedelta

class PasswordPolicy:
    """
    Política de contraseñas para Legit Health Plus
    """

    POLICIES = {
        "standard": {
            "min_length": 12,
            "require_uppercase": 1,
            "require_lowercase": 1,
            "require_numbers": 1,
            "require_special": 1,
            "history_count": 12,
            "expiry_days": 90,
            "max_attempts": 5,
            "lockout_minutes": 30
        },
        "privileged": {
            "min_length": 15,
            "require_uppercase": 2,
            "require_lowercase": 2,
            "require_numbers": 2,
            "require_special": 2,
            "history_count": 24,
            "expiry_days": 60,
            "max_attempts": 3,
            "lockout_minutes": 60
        },
        "admin": {
            "min_length": 20,
            "require_uppercase": 3,
            "require_lowercase": 3,
            "require_numbers": 3,
            "require_special": 3,
            "history_count": 36,
            "expiry_days": 30,
            "max_attempts": 3,
            "lockout_minutes": -1  # Manual unlock required
        }
    }

    def validate_password(self, password: str, user_type: str = "standard") -> tuple:
        """
        Valida una contraseña según la política
        """
        policy = self.POLICIES[user_type]
        errors = []

        # Longitud
        if len(password) < policy["min_length"]:
            errors.append(f"Mínimo {policy['min_length']} caracteres")

        # Mayúsculas
        uppercase_count = len(re.findall(r'[A-Z]', password))
        if uppercase_count < policy["require_uppercase"]:
            errors.append(f"Mínimo {policy['require_uppercase']} mayúsculas")

        # Minúsculas
        lowercase_count = len(re.findall(r'[a-z]', password))
        if lowercase_count < policy["require_lowercase"]:
            errors.append(f"Mínimo {policy['require_lowercase']} minúsculas")

        # Números
        number_count = len(re.findall(r'[0-9]', password))
        if number_count < policy["require_numbers"]:
            errors.append(f"Mínimo {policy['require_numbers']} números")

        # Caracteres especiales
        special_count = len(re.findall(r'[!@#$%^&*(),.?":{}|<>]', password))
        if special_count < policy["require_special"]:
            errors.append(f"Mínimo {policy['require_special']} caracteres especiales")

        # Verificar contra diccionarios comunes
        if self.is_common_password(password):
            errors.append("Contraseña demasiado común")

        # Verificar patrones predecibles
        if self.has_predictable_pattern(password):
            errors.append("Contraseña contiene patrones predecibles")

        return (len(errors) == 0, errors)

    def generate_secure_password(self, user_type: str = "standard") -> str:
        """
        Genera una contraseña segura según política
        """
        policy = self.POLICIES[user_type]

        # Conjuntos de caracteres
        uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        lowercase = "abcdefghijklmnopqrstuvwxyz"
        numbers = "0123456789"
        special = "!@#$%^&*(),.?":{}|<>"

        password = []

        # Asegurar mínimos requeridos
        for _ in range(policy["require_uppercase"]):
            password.append(secrets.choice(uppercase))
        for _ in range(policy["require_lowercase"]):
            password.append(secrets.choice(lowercase))
        for _ in range(policy["require_numbers"]):
            password.append(secrets.choice(numbers))
        for _ in range(policy["require_special"]):
            password.append(secrets.choice(special))

        # Completar longitud
        all_chars = uppercase + lowercase + numbers + special
        remaining = policy["min_length"] - len(password)
        for _ in range(remaining):
            password.append(secrets.choice(all_chars))

        # Mezclar aleatoriamente
        secrets.SystemRandom().shuffle(password)

        return ''.join(password)

Autenticación Federada y SSO

Proveedores de Identidad Soportados

Proveedor	Protocolo	Uso Principal	Configuración
Azure AD	SAML 2.0 / OIDC	Hospitales con Microsoft	Federación completa
Google Workspace	OAuth 2.0 / OIDC	Clínicas pequeñas	SSO simplificado
Okta	SAML 2.0 / OIDC	Empresas sanitarias	Integración avanzada
Custom LDAP	LDAP/LDAPS	Sistemas legacy	Bridge authentication
DNIe / Certificados	X.509	Administración pública	PKI nacional

Gestión de Sesiones

Parámetros de Sesión

{
  "session_config": {
    "standard_user": {
      "timeout_minutes": 30,
      "absolute_timeout_hours": 8,
      "concurrent_sessions": 3,
      "idle_warning_minutes": 5
    },
    "privileged_user": {
      "timeout_minutes": 15,
      "absolute_timeout_hours": 4,
      "concurrent_sessions": 1,
      "idle_warning_minutes": 2
    },
    "api_client": {
      "token_expiry_minutes": 60,
      "refresh_token_days": 7,
      "rate_limit_per_minute": 100
    }
  }
}

Procedimientos

PRO-AAC-013: Configuración Inicial de Autenticación

1. Provisión de Credenciales

   • Generación de credenciales temporales
   • Envío por canal seguro
   • Activación con cambio obligatorio
   • Configuración de MFA

2. Verificación de Identidad

   • Validación documental
   • Confirmación telefónica
   • Activación presencial si crítico

3. Registro de Factores

   • Configuración de TOTP
   • Registro biométrico si aplica
   • Backup codes generation

PRO-AAC-015: Gestión de Privilegios de Administración

1. Clasificación de Accesos Privilegiados

Nivel de Privilegio	Descripción	Autenticación Requerida	Revisión
Super Admin	Acceso root completo a infraestructura	Hardware Token + Biometría + PIN	Semanal
System Admin	Administración de sistemas operativos	Hardware Token + MFA	Quincenal
DB Admin	Gestión de bases de datos clínicas	Certificado + MFA	Quincenal
Security Admin	Configuración de seguridad	Hardware Token + MFA	Semanal
Application Admin	Configuración de aplicaciones	MFA + Aprobación	Mensual

2. Procedimiento de Elevación de Privilegios

class PrivilegeEscalationManager:
    """
    Gestión de elevación temporal de privilegios
    """

    def request_elevation(self, user_id: str, privilege_level: str,
                         justification: str, duration_hours: int = 4) -> str:
        """
        Solicitar elevación temporal de privilegios
        """

        # Validar usuario y nivel solicitado
        if not self.validate_user_eligibility(user_id, privilege_level):
            raise SecurityException("Usuario no elegible para este nivel")

        # Verificar MFA adicional para privilegios críticos
        if privilege_level in ['super_admin', 'security_admin']:
            if not self.verify_additional_mfa(user_id):
                raise SecurityException("MFA adicional requerida")

        # Crear solicitud de elevación
        request = {
            'request_id': self.generate_request_id(),
            'user_id': user_id,
            'privilege_level': privilege_level,
            'justification': justification,
            'requested_duration': duration_hours,
            'timestamp': datetime.utcnow(),
            'status': 'pending_approval'
        }

        # Enviar a aprobación si requerida
        if self.requires_approval(privilege_level):
            return self.send_for_approval(request)
        else:
            return self.grant_elevation(request)

    def grant_elevation(self, request: dict) -> str:
        """
        Conceder elevación de privilegios
        """

        # Crear token de sesión privilegiada
        privileged_token = self.create_privileged_token(
            request['user_id'],
            request['privilege_level'],
            request['requested_duration']
        )

        # Registrar actividad
        self.log_privilege_elevation(request, 'granted')

        # Programar revocación automática
        self.schedule_privilege_revocation(
            privileged_token,
            request['requested_duration']
        )

        return privileged_token

3. Just-In-Time (JIT) Access Management

Configuración JIT por Sistema:

jit_access_config:
  production_database:
    max_duration_hours: 2
    approval_required: true
    approvers: ["db_lead", "security_lead"]
    additional_mfa: true
    session_recording: true

  kubernetes_cluster:
    max_duration_hours: 4
    approval_required: true
    approvers: ["devops_lead"]
    additional_mfa: true
    commands_whitelist: ["kubectl get", "kubectl describe"]

  aws_production:
    max_duration_hours: 1
    approval_required: true
    approvers: ["cloud_architect", "security_lead"]
    additional_mfa: true
    role_assumption: "arn:aws:iam::account:role/emergency-access"

PRO-AAC-016: Revisiones Obligatorias de Acceso

1. Calendario de Revisiones

Tipo de Acceso	Frecuencia	Responsable	Herramienta
Accesos Privilegiados	Semanal	Security Admin	PAM Dashboard
Accesos Clínicos	Mensual	Clinical Lead	Access Review Portal
Accesos API	Quincenal	API Manager	API Gateway Console
Accesos Externos	Mensual	Partnership Manager	Identity Provider
Cuentas de Servicio	Trimestral	DevOps Lead	Service Account Audit

2. Proceso de Revisión Automatizada

class AccessReviewManager:
    """
    Gestión automatizada de revisiones de acceso
    """

    def generate_review_report(self, review_type: str,
                              period_days: int = 30) -> dict:
        """
        Genera informe de revisión de accesos
        """

        end_date = datetime.utcnow()
        start_date = end_date - timedelta(days=period_days)

        report = {
            'review_type': review_type,
            'period': f"{start_date.date()} to {end_date.date()}",
            'total_accounts': 0,
            'active_accounts': 0,
            'inactive_accounts': 0,
            'privileged_accounts': 0,
            'anomalies': [],
            'recommendations': []
        }

        # Obtener datos de acceso
        access_data = self.get_access_data(review_type, start_date, end_date)

        # Analizar patrones de uso
        for account in access_data:
            report['total_accounts'] += 1

            if self.is_account_active(account, period_days):
                report['active_accounts'] += 1
            else:
                report['inactive_accounts'] += 1

            if self.is_privileged_account(account):
                report['privileged_accounts'] += 1

            # Detectar anomalías
            anomalies = self.detect_access_anomalies(account)
            report['anomalies'].extend(anomalies)

        # Generar recomendaciones
        report['recommendations'] = self.generate_recommendations(report)

        return report

    def detect_access_anomalies(self, account: dict) -> list:
        """
        Detecta anomalías en patrones de acceso
        """
        anomalies = []

        # Acceso desde ubicaciones inusuales
        unusual_locations = self.detect_unusual_locations(account)
        if unusual_locations:
            anomalies.append({
                'type': 'unusual_location',
                'account': account['user_id'],
                'details': f"Acceso desde: {', '.join(unusual_locations)}"
            })

        # Horarios inusuales
        unusual_hours = self.detect_unusual_hours(account)
        if unusual_hours:
            anomalies.append({
                'type': 'unusual_hours',
                'account': account['user_id'],
                'details': f"Acceso fuera de horario: {unusual_hours}"
            })

        # Privilegios no utilizados
        unused_privileges = self.detect_unused_privileges(account)
        if unused_privileges:
            anomalies.append({
                'type': 'unused_privileges',
                'account': account['user_id'],
                'details': f"Privilegios sin usar: {', '.join(unused_privileges)}"
            })

        return anomalies

3. Matriz de Certificación de Accesos

Template de Certificación Mensual:

## CERTIFICACIÓN DE ACCESOS - {MES/AÑO}

### Resumen Ejecutivo

- Total de cuentas revisadas: {TOTAL}
- Cuentas activas certificadas: {ACTIVAS}
- Cuentas desactivadas: {DESACTIVADAS}
- Anomalías detectadas: {ANOMALÍAS}
- Acciones correctivas: {ACCIONES}

### Revisión por Tipo de Acceso

#### Accesos Privilegiados

| Usuario | Rol       | Último Acceso | Justificación            | Acción   |
| ------- | --------- | ------------- | ------------------------ | -------- |
| user001 | DB Admin  | 2025-08-28    | Mantenimiento programado | Mantener |
| user002 | Sys Admin | 2025-07-15    | Sin actividad reciente   | Revocar  |

#### Accesos Clínicos

| Usuario | Especialidad     | Pacientes Accedidos | Justificación    | Acción   |
| ------- | ---------------- | ------------------- | ---------------- | -------- |
| dr001   | Dermatología     | 45                  | Actividad normal | Mantener |
| dr002   | Medicina General | 2                   | Baja actividad   | Revisar  |

### Certificación de Responsables

- **Responsable Seguridad**: [Nombre] - [Firma] - [Fecha]
- **Responsable Clínico**: [Nombre] - [Firma] - [Fecha]
- **Responsable IT**: [Nombre] - [Firma] - [Fecha]

PRO-AAC-017: Gestión de Cuentas de Servicio

1. Registro de Cuentas de Servicio

{
  "service_accounts_registry": {
    "api-gateway-prod": {
      "purpose": "Autenticación API Gateway producción",
      "owner": "devops-team",
      "created_date": "2025-01-15",
      "last_rotated": "2025-08-01",
      "rotation_schedule": "quarterly",
      "privileges": ["api-gateway-read", "cognito-validate"],
      "networks_allowed": ["10.0.1.0/24"],
      "monitoring": {
        "alert_on_unusual_activity": true,
        "max_requests_per_minute": 1000
      }
    },
    "backup-service": {
      "purpose": "Servicio automático de backups",
      "owner": "infrastructure-team",
      "created_date": "2025-01-20",
      "last_rotated": "2025-08-15",
      "rotation_schedule": "monthly",
      "privileges": ["s3-backup-write", "rds-snapshot"],
      "networks_allowed": ["10.0.2.0/24"],
      "schedule": "daily at 02:00 UTC"
    }
  }
}

2. Rotación Automática de Credenciales

class ServiceAccountManager:
    """
    Gestión automática de cuentas de servicio
    """

    def rotate_service_credentials(self, service_account_id: str) -> bool:
        """
        Rotar credenciales de cuenta de servicio
        """

        try:
            # Generar nuevas credenciales
            new_credentials = self.generate_service_credentials()

            # Actualizar en el servicio de secretos
            self.update_secret_manager(service_account_id, new_credentials)

            # Actualizar aplicaciones que usan esta cuenta
            self.update_dependent_services(service_account_id, new_credentials)

            # Período de gracia para actualización
            time.sleep(300)  # 5 minutos

            # Revocar credenciales anteriores
            self.revoke_old_credentials(service_account_id)

            # Registrar rotación exitosa
            self.log_credential_rotation(service_account_id, 'success')

            return True

        except Exception as e:
            self.log_credential_rotation(service_account_id, 'failed', str(e))
            # Rollback si es necesario
            self.rollback_credential_rotation(service_account_id)
            return False

    def monitor_service_account_usage(self, service_account_id: str) -> dict:
        """
        Monitorizar uso de cuenta de servicio
        """

        usage_stats = {
            'requests_last_24h': 0,
            'unique_sources': 0,
            'error_rate': 0.0,
            'unusual_patterns': [],
            'compliance_status': 'compliant'
        }

        # Obtener métricas de uso
        logs = self.get_service_account_logs(service_account_id, hours=24)

        usage_stats['requests_last_24h'] = len(logs)
        usage_stats['unique_sources'] = len(set(log['source_ip'] for log in logs))

        # Calcular tasa de error
        error_logs = [log for log in logs if log['status_code'] >= 400]
        if logs:
            usage_stats['error_rate'] = len(error_logs) / len(logs)

        # Detectar patrones inusuales
        usage_stats['unusual_patterns'] = self.detect_unusual_service_patterns(logs)

        # Evaluar cumplimiento
        if usage_stats['error_rate'] > 0.1:  # >10% errores
            usage_stats['compliance_status'] = 'attention_required'

        if usage_stats['unusual_patterns']:
            usage_stats['compliance_status'] = 'investigation_needed'

        return usage_stats

PRO-AAC-014: Gestión de Incidentes de Autenticación

1. Bloqueo por Intentos Fallidos

   • Notificación automática al usuario
   • Alerta al SOC
   • Proceso de desbloqueo verificado

2. Compromiso de Credenciales

   • Bloqueo inmediato
   • Reset forzado de contraseña
   • Auditoría de accesos recientes
   • Notificación a afectados

3. Pérdida de Factor MFA

   • Verificación de identidad alternativa
   • Uso de backup codes
   • Re-registro de factor

4. Respuesta a Anomalías de Acceso Privilegiado

   class PrivilegedAccessIncidentResponse:
       """
       Respuesta automática a incidentes de acceso privilegiado
       """
   
       def handle_privilege_anomaly(self, anomaly: dict) -> str:
           """
           Maneja anomalías en accesos privilegiados
           """
   
           incident_id = self.create_incident(anomaly)
   
           # Evaluar severidad
           severity = self.calculate_anomaly_severity(anomaly)
   
           if severity == 'critical':
               # Suspender acceso inmediatamente
               self.suspend_privileged_access(anomaly['user_id'])
   
               # Notificar al CISO y Security Team
               self.notify_security_team(incident_id, 'critical')
   
               # Iniciar investigación forense
               self.initiate_forensic_investigation(incident_id)
   
           elif severity == 'high':
               # Requerir re-autenticación
               self.require_reauthentication(anomaly['user_id'])
   
               # Notificar al Security Team
               self.notify_security_team(incident_id, 'high')
   
               # Aumentar monitorización
               self.increase_monitoring(anomaly['user_id'], hours=24)
   
           elif severity == 'medium':
               # Registrar para revisión
               self.flag_for_review(anomaly['user_id'])
   
               # Notificar al gestor del usuario
               self.notify_user_manager(anomaly['user_id'], incident_id)
   
           return incident_id

5. Procedimiento de Investigación de Accesos Anómalos

   Fase 1: Detección Automática (0-5 minutos)

   • SIEM detecta patrón anómalo
   • Sistema clasifica automáticamente el riesgo
   • Se activan contramedidas automáticas según severidad

   Fase 2: Análisis Inicial (5-30 minutos)

   • Analista de seguridad revisa alertas
   • Correlación con otros eventos de seguridad
   • Validación de falsos positivos

   Fase 3: Investigación Detallada (30 minutos - 4 horas)

   • Análisis forense de logs de autenticación
   • Revisión de actividades del usuario
   • Contacto con el usuario para validación

   Fase 4: Resolución y Documentación (4-24 horas)

   • Implementación de medidas correctivas
   • Documentación de lecciones aprendidas
   • Actualización de reglas de detección

Responsabilidades

Chief Information Security Officer (CISO)

• Definir políticas de autenticación
• Aprobar métodos y tecnologías
• Supervisar cumplimiento

Identity and Access Management (IAM) Team

• Implementar sistemas de autenticación
• Gestionar ciclo de vida de credenciales
• Mantener integraciones federadas

Security Operations Center (SOC)

• Monitorizar intentos de autenticación
• Detectar y responder a anomalías
• Gestionar incidentes de seguridad

Usuarios

• Proteger sus credenciales
• Reportar incidentes inmediatamente
• Cumplir políticas establecidas

Registros y Evidencias

Logs de Autenticación

{
  "authentication_log": {
    "timestamp": "2024-01-20T10:30:45Z",
    "event_type": "LOGIN_SUCCESS",
    "user_id": "LH-HCP-12345",
    "authentication_method": "PASSWORD_MFA",
    "mfa_type": "TOTP",
    "ip_address": "192.168.1.100",
    "user_agent": "Mozilla/5.0...",
    "location": "Madrid, ES",
    "risk_score": 0.2,
    "session_id": "sess_abc123"
  }
}

Métricas y KPIs

KPIs Básicos de Autenticación

Métrica	Objetivo	Frecuencia	Responsable
Tasa de adopción MFA	100%	Semanal	IAM Team
Intentos de autenticación fallidos	<5%	Diario	SOC
Tiempo medio de autenticación	<3 segundos	Continuo	DevOps
Incidentes de compromiso	0	Mensual	CISO
Contraseñas expiradas activas	0%	Diario	IAM Team
Sesiones concurrentes anómalas	<1%	Continuo	SOC

KPIs de Gestión de Privilegios (ENS)

Métrica ENS	Objetivo	Medición	Responsable
Revisiones de acceso completadas	100% en plazo	Mensual	Access Manager
Accesos privilegiados sin usar	<5%	Semanal	Security Admin
Tiempo de revocación de acceso	<4 horas	Por solicitud	IAM Team
Cumplimiento rotación credenciales	100%	Automático	System
Certificación de accesos médicos	100% mensual	Mensual	Clinical Lead
Anomalías de acceso detectadas	100% investigadas	Continuo	SOC
JIT access requests processed	<2 horas	Por solicitud	Security Team

Métricas de Cumplimiento ENS

class ENSComplianceMetrics:
    """
    Métricas específicas de cumplimiento ENS para OP.ACC.5
    """

    def generate_monthly_report(self) -> dict:
        """
        Genera informe mensual de cumplimiento
        """

        report = {
            'period': datetime.now().strftime('%Y-%m'),
            'mfa_compliance': self.calculate_mfa_compliance(),
            'password_policy_compliance': self.calculate_password_compliance(),
            'privilege_review_compliance': self.calculate_privilege_compliance(),
            'service_account_compliance': self.calculate_service_account_compliance(),
            'anomaly_response_compliance': self.calculate_anomaly_response_compliance()
        }

        # Calcular puntuación general de cumplimiento
        compliance_scores = [
            report['mfa_compliance']['score'],
            report['password_policy_compliance']['score'],
            report['privilege_review_compliance']['score'],
            report['service_account_compliance']['score'],
            report['anomaly_response_compliance']['score']
        ]

        report['overall_compliance_score'] = sum(compliance_scores) / len(compliance_scores)
        report['compliance_level'] = self.determine_compliance_level(
            report['overall_compliance_score']
        )

        return report

    def calculate_mfa_compliance(self) -> dict:
        """
        Calcula cumplimiento de MFA
        """
        total_users = self.get_total_active_users()
        mfa_enabled_users = self.get_mfa_enabled_users()

        compliance_rate = (mfa_enabled_users / total_users) * 100 if total_users > 0 else 0

        return {
            'total_users': total_users,
            'mfa_enabled': mfa_enabled_users,
            'compliance_rate': compliance_rate,
            'score': min(compliance_rate, 100),
            'status': 'compliant' if compliance_rate >= 100 else 'non_compliant',
            'gap': max(0, total_users - mfa_enabled_users)
        }

Referencias Cruzadas

Documentos Internos

• OP.AAC.1: Identificación - Base para autenticación
• OP.AAC.4: Gestión de derechos - Post-autenticación
• T-024-009: Security Architecture - Detalles técnicos
• GP-013: Ciberseguridad - Marco general
• T-110-007: Matriz RACI - Roles y responsabilidades ENS
• T-110-008: CCN-CERT - Procedimientos de notificación

Cumplimiento Normativo

• ENS: [op.acc.5] Mecanismo de autenticación
• ISO 27001: A.9.4.2 - Procedimientos seguros de inicio de sesión
• MDR: Requisito 17.2 - Medidas de seguridad IT
• FDA Cybersecurity: Autenticación robusta
• NIST 800-63B: Digital Identity Guidelines

Documentos de referencia

• Guías CCN-STIC:
  • Guía CCN-STIC-436 - Herramientas de Análisis de Contraseñas
  • Guía CCN-STIC-490 Dispositivos biométricos de huella dactilar
  • Guía CCN-STIC-807 - Criptología de Empleo en el ENS
  • Guía CCN-STIC-827 - Gestión y uso de dispositivos móviles
• ISO/IEC 27000
  • 27002:2013:
    • 9.2.4 - Gestión de la información secreta de autenticación de usuarios
    • 9.3.1 - Uso de la información secreta de autenticación
    • 9.4.3 - Sistema de gestión de contraseñas
• NIST SP 800-53 rev4:
  • [IA-2] Identification and Authentication (Organizational Users)
  • [IA-3] Device Identification and Authentication
  • [IA-5] Authenticator Management
  • [IA-7] Cryptographic Module Authentication
  • [IA-8] Identification and Authentication (Non-Organizational Users)
• Otras referencias:
  • SANS - CIS Critical Security Controls - Version 6.1
    • CSC.5 - Controlled Use of Administrative Privileges
    • CSC.14 - Controlled Access Based on the Need to Know
  • Password Policy, SANS Institute http://www.sans.org/resources/policies/Password_Policy.pdf

Definiciones

• Hash o funciones resumen: La función de hashing criptográfico es una función (matemática) en la cual un algoritmo conocido toma un mensaje de longitud arbitraria como entrada y produce un resultado de longitud fija (generalmente denominado “código hash” o “resumen de mensaje”).
• Personal Identification Number es un número de identificación personal utilizado en ciertos sistemas, como el teléfono móvil o el cajero automático, para identificarse y obtener acceso al sistema. Es un tipo de contraseña.
• Tokens: Tarjeta o dispositivo electrónico que utiliza un usuario autorizado para acceder a un sistema informático.

Guía de implantación

128. Es el mecanismo que permite validar la identidad de un usuario. Es crítico por cuanto la identificación del usuario es, en general, fácilmente accesible.

129. Típicamente los mecanismos de autenticación recurren:

• a algo que se conoce (un secreto, por ejemplo, una contraseña)
• a algo que se tiene (un objeto, por ejemplo, una tarjeta o una llave)
• a algo que es propio del usuario (características biométricas)

130. A veces estos mecanismos se emplean por pares para dificultar la falsificación y ganar tiempo frente a la pérdida de alguno de los mecanismos. Como, por ejemplo:

• una tarjeta + un PIN
• una tarjeta + una característica biométrica
• una característica biométrica + una contraseña

131. Cada mecanismo tiene sus puntos débiles que deben atajarse por medio de normativa y procedimientos que regulen su uso, periodo de validez y gestión de incidencias tales como la pérdida por parte del usuario legítimo.

Factor de autenticación	Ejemplos	Bajo	Medio	Alto
Algo que se sabe	Contraseñas, claves concertadas, PIN	ok	con cautela	con cautela
Algo que se tiene	Tokens, tarjetas	ok	ok	criptográficos
Algo que se es	Biometría	ok	ok	ok

Mecanismos de autenticación según nivel de dimensiones de seguridad

132. Las credenciales deberán activarse una vez estén bajo control efectivo del usuario (por ejemplo, contraseña temporal de un solo uso) y serán única y exclusivamente para dicho usuario, prohibiéndose su divulgación o uso compartido. Es decir, el usuario deberá reconocer que ha recibido las credenciales y que conoce y acepta las obligaciones que implica su tenencia, en particular, el deber de custodia diligente, protección de su confidencialidad e información inmediata en caso de pérdida.

133. Las credenciales caducarán con una periodicidad marcada por la política de la organización, aunque la entidad (persona, equipo o proceso) haga uso habitual de ellas.

134. Las credenciales se retirarán y serán inhabilitadas cuando la entidad (persona, equipo o proceso) que autentican:

• Termina su relación con el sistema
• Tras un periodo definido de no utilización

135. Además, debe contemplarse la posibilidad de que las aplicaciones y otros elementos tecnológicos de seguridad de los que se haga uso, sobre todo si se usan productos comerciales, no tengan la capacidad para permitir una adecuada configuración de los mecanismos de autenticación atendiendo al Esquema Nacional de Seguridad y a la categoría del sistema. Por ello deberán tenerse en cuenta las siguientes opciones:

• Adquirir productos con la capacidad de cumplir los requisitos exigidos.
• Disponer de otros elementos o medidas previas que suplan las carencias de los productos comerciales (por ejemplo, autenticación contra LDAP o Directorio Activo, máquinas de salto para autenticar en elementos de seguridad con configuración limitada, etc.).
• Reemplazar las medidas de seguridad por otras compensatorias siempre y cuando se justifique documentalmente que protegen igual o mejor el riesgo sobre los activos y sea aprobado formalmente por el Responsable de la Seguridad, tal como se indica en el Artículo 27 del Real Decreto 3/2010, de 8 de Enero.

Contraseñas (secretos compartidos en general)

136. Características:

• se pueden olvidar
• a veces los usuarios las escriben abriendo una oportunidad al conocimiento por robo
• si el número de posibilidades es reducido y el mecanismo de validación permite probar rápidamente, un atacante puede descubrir el secreto a base de pruebas
• nótese que la revelación de un secreto puede producirse sin el conocimiento de la parte afectada por lo que el ladrón dispone de una amplia ventana de tiempo para actuar maximizando sus oportunidades
• la principal ventaja es que son baratas de implantar y fáciles de reemplazar en caso de pérdida

137. Se debe concienciar a los usuarios de los riesgos del uso de contraseñas e instruirles en cómo generarlas y custodiarlas.

138. La expresión “con cautela” empleada más arriba indica que debemos establecer una política rigurosa de empleo de contraseñas como mecanismo de autenticación. Una política incluye los siguientes elementos:

• La Política de contraseñas debe formalizarse en normativa [org.2] y procedimientos operativos de seguridad [org.3].
• Debe diferenciar entre contraseñas de usuario y contraseñas con privilegios de administrador.
• Debe tener en cuenta si se emplea aisladamente o en combinación con otro factor de autenticación.
• Debe fijar los procesos de creación, distribución, custodia y terminación.
• Debe establecer las características (patrones) de las contraseñas para considerarse válidas. Por ejemplo, número de caracteres y conjunto admitido y requerido de caracteres.
• Debe establecer un periodo máximo de validez y un tiempo mínimo de no repetición (por ejemplo, hay que renovarla al menos cada 6 meses y no se puede establecer una contraseña ya utilizada en los últimos 3 años).
• Deben detectarse los intentos repetidos de utilización y tratarlos como posibles ataques de descubrimiento por el método de prueba-error. Y debe establecerse un procedimiento de actuación que puede ir desde la introducción de un retardo creciente en el mecanismo de validación, hasta la suspensión cautelar de la cuenta.
• Debe ejecutarse regularmente una aplicación de descubrimiento de contraseñas por fuerza bruta (password cracker), suspendiéndose de oficio todas las contraseñas rotas.
• Deben suspenderse las contraseñas que hayan sido utilizadas con éxito en un proceso de autenticación de doble factor, incluso si el segundo factor ha bloqueado el acceso.
• Deben establecerse planes de concienciación y formación de los usuarios y administradores que emplean contraseñas.

139. Se debe implementar un procedimiento de resolución de incidencias relacionadas con incidentes relacionados con contraseñas; en particular debe haber un procedimiento urgente de suspensión de cuenta tras un robo.

Claves concertadas

140. Las claves concertadas son una variante de las contraseñas, que se suponen más cómodas de establecer para el ciudadano usuario.

141. Se entienden por claves concertadas códigos generados previa identificación y autenticación del ciudadano por otros medios. Jurídicamente, el ciudadano expresa su voluntad de utilizar este mecanismo en el proceso de solicitud. Las claves concertadas deberán garantizar que el usuario no puede ser suplantado, ni por otro usuario, ni por la propia Administración. Para ello deberán:

• ser razonablemente robustas frente a ataques de adivinación, tanto por estar asociadas a datos ampliamente conocidos del ciudadano, como por falta de aleatoriedad suficiente en la generación
• ser razonablemente robustas frente a ataques de diccionario
• ser razonablemente robustas frente a ataques de fuerza bruta; es decir, deben disponer de suficiente entropía
• impedir que el ciudadano pueda ser suplantado por su contraparte en la Administración
• seguir un procedimiento de generación que garantice la autenticidad del ciudadano
• seguir un procedimiento de comunicación al interesado que garantice que llega a la persona correcta
• disponer de un procedimiento de comunicación de pérdida o robo que suspenda inmediatamente la operatividad de la clave
• disponer de procedimientos de custodia de los datos de firma y verificación de la firma durante el período de validez de la información firmada, incluyendo los instantes de tiempo en que se genera, se suspende y se extingue la validez de la clave concertada

142. A fin de garantizar la robustez, la Administración deberá recurrir a generadores aleatorios que proporcionen suficiente entropía (que hayan tantas claves posibles que sea imposible probarlas todas una por una).

143. Es responsabilidad del usuario custodiar dichas claves de forma segura.

144. El proceso de generación debe garantizar la identidad del sujeto y dejar evidencia documental de las pruebas de identidad empleadas.

145. El procedimiento de distribución debe garantizar que sólo se le facilita al titular legítimo. Por ejemplo:

• usando una red privada virtual cifrada y autenticada (mp.com.2 y mp.com.3)
• por doble canal; ej. Internet + teléfono móvil
• por escrito en sobre cerrado

146. Deben generarse de forma aleatoria para:

• resistir ataques de adivinación
• resistir ataques de diccionario

Llaves o tarjetas

147. Características:

• se pueden perder, accidental o deliberadamente
• se pueden robar
• se pueden hacer copias
• en general, son caras y difíciles de reemplazar en caso de pérdida o deterioro

148. Uso habitual:

• autenticación frente a terminales (logon)
• acceso remoto y establecimiento de canales seguros
• activación de dispositivos criptográficos
• uso de dos o más tarjetas de activación
• acceso a instalaciones

149. Parece natural que se potencie el uso del DNI electrónico como mecanismo de autenticación de la persona. Este dispositivo proporciona medios de autenticación criptográficos acreditados. Frente a su uso no autorizado se protege con un PIN de activación. Nótese que el DNI electrónico sólo está capacitado por política para identificar a la persona; el resto del sistema de control y registro de acceso debe implementarse aparte.

150. Otras tarjetas de la administración pueden proporcionar funciones de autenticación del usuario asociadas a las funciones propias de su cargo en el organismo.

151. En sistemas de nivel Alto, se deben utilizar elementos criptográficos hardware que utilicen algoritmos y parámetros acreditados por el Centro Criptológico Nacional. La Guía CCN-STIC-807 Criptografía (claves de autenticación y certificados electrónicos) indica los tipos de clave pública y funciones hash que se pueden utilizar para los diferentes niveles (bajo, medio y alto).

Biometría

152. Características:

• normalmente no son secretas, y su robustez depende de que no se pueda suplantar al usuario; esto depende mucho del mecanismo concreto, pero algunos permiten técnicas de reproducción un tanto avanzadas.
• en general los dispositivos son costosos
• es difícil de reemplazar en caso de pérdida del control por parte del usuario legítimo

153. Uso habitual:

• En la autenticación frente a terminales:

  • reconocimiento de huella dactilar
  • reconocimiento facial
  • como doble factor se puede usar una contraseña o un PIN

• En el acceso a locales o áreas:

  • reconocimiento de la mano
  • reconocimiento del iris o del fondo del ojo
  • como doble factor se puede utilizar una tarjeta o un PIN

Signature meaning

The signatures for the approval process of this document can be found in the verified commits at the repository for the QMS. As a reference, the team members who are expected to participate in this document and their roles in the approval process, as defined in Annex I Responsibility Matrix of the GP-001, are:

• Author: Team members involved
• Reviewer: JD-003, JD-004
• Approver: JD-001