Ir al contenido principal
Español— Elegir un idioma
Menú

Auditoría de seguridad y certificación

Lección 14 de 14 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. De la seguridad ad hoc al cumplimiento certificable
  2. Conoce qué marco se aplica
  3. Una lista de comprobación que abarca cinco dominios
  4. Auditar significa exigir pruebas
  5. Automatiza lo que puedas
  6. Qué espera un certificador
  7. Puntos clave
  8. Pon a prueba tus conocimientos

De la seguridad ad hoc al cumplimiento certificable

Las lecciones anteriores te han proporcionado las herramientas técnicas para asegurar un sistema de IA. Sin embargo, las comprobaciones de seguridad puntuales no son suficientes, y la razón no es mera burocracia. Lo que verificas una vez deja de estar verificado en cuanto publicas la siguiente versión, y nada señala esa brecha. Clientes, reguladores y socios exigen pruebas formales: demostración de que tus controles existen, funcionan y se mantienen en el tiempo. La auditoría y la certificación convierten tus prácticas en un marco verificable y continuo.

Conoce qué marco se aplica

Cinco marcos convergen en la IA, cada uno con un alcance distinto. Distingue entre ellos antes de comprometerte con ninguno.

Estándar Alcance Relevancia para IA
ISO 27001 Seguridad de la información Base para cualquier sistema que procese datos
ISO 42001 Gestión de la IA Específico de IA: gobernanza, riesgo, ciclo de vida
Ley de IA (UE) Regulación europea Obligatoria para sistemas de alto riesgo en la UE
SOC 2 Tipo II Controles de seguridad SaaS Exigido por clientes empresariales
OWASP LLM Top 10 Mejores prácticas de seguridad para LLM Lista de comprobación de referencia para auditoría técnica

La distinción decisiva separa lo obligatorio de lo opcional. La Ley de IA de la UE es un reglamento: si tu sistema entra en la categoría de alto riesgo, no puedes optar por no cumplirlo. Las normas ISO y SOC 2 son certificaciones voluntarias, exigidas habitualmente por clientes empresariales más que por reguladores. El OWASP LLM Top 10 no es certificable; es una referencia técnica y constituye el mejor punto de partida para una primera auditoría interna porque solo requiere tiempo.

Una lista de comprobación que abarca cinco dominios

Una auditoría seria va más allá de lo técnico. La siguiente lista de comprobación distribuye sus puntos de control en cinco dominios, y esa distribución cuenta una historia: la gobernanza y el cumplimiento pesan tanto como la seguridad, porque una configuración técnica impecable que nadie asume y que no está documentada en ningún sitio fracasará en cualquier auditoría externa.

La criticidad separa lo obligatorio de lo recomendado, una distinción que luego impulsa una decisión binaria. El aislamiento (sandboxing) aparece como recomendado y no como obligatorio, y esa jerarquía está justificada: solo se aplica a sistemas que ejecutan código generado, mientras que el filtrado de entradas y salidas afecta a todas las aplicaciones sin excepción. Una lista de comprobación bien calibrada no le pide a un chatbot de preguntas frecuentes que justifique el aislamiento de contenedores.

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class ControlPoint:
    id: str
    category: str
    description: str
    criticality: str  # mandatory, recommended, optional
    compliant: bool | None = None
    evidence: str = ""
    comment: str = ""

def create_audit_checklist() -> list[ControlPoint]:
    """Crea una lista de comprobación exhaustiva para auditoría de seguridad de IA."""
    return [
        # Gobernanza
        ControlPoint("GOV-01", "Governance",
            "Política de seguridad de IA documentada y aprobada", "mandatory"),
        ControlPoint("GOV-02", "Governance",
            "Responsable designado de seguridad de IA (CISO/DPO)", "mandatory"),
        ControlPoint("GOV-03", "Governance",
            "Registro actualizado de actividades de procesamiento de IA", "mandatory"),

        # Datos
        ControlPoint("DAT-01", "Data",
            "Inventario de datos enviados a APIs de LLM", "mandatory"),
        ControlPoint("DAT-02", "Data",
            "Anonimización/seudonimización de datos personales", "mandatory"),
        ControlPoint("DAT-03", "Data",
            "DPA firmado con cada proveedor de API de IA", "mandatory"),
        ControlPoint("DAT-04", "Data",
            "Política de retención de conversaciones definida", "mandatory"),

        # Seguridad técnica
        ControlPoint("SEC-01", "Security",
            "Inyección de prompts: defensa en profundidad implementada", "mandatory"),
        ControlPoint("SEC-02", "Security",
            "Filtrado de contenido (entradas y salidas)", "mandatory"),
        ControlPoint("SEC-03", "Security",
            "Limitación de tasa y detección de abusos", "mandatory"),
        ControlPoint("SEC-04", "Security",
            "Claves de API almacenadas en una bóveda (no hardcodeadas)", "mandatory"),
        ControlPoint("SEC-05", "Security",
            "Aislamiento (sandboxing) para ejecución de código generado", "recommended"),
        ControlPoint("SEC-06", "Security",
            "Monitorización y alertas sobre anomalías", "recommended"),

        # Red teaming
        ControlPoint("RED-01", "Red teaming",
            "Pruebas de seguridad antes de cada lanzamiento a producción", "mandatory"),
        ControlPoint("RED-02", "Red teaming",
            "Red teaming regular (mínimo trimestral)", "recommended"),
        ControlPoint("RED-03", "Red teaming",
            "Informe de red teaming con seguimiento de remediación", "mandatory"),

        # Cumplimiento normativo
        ControlPoint("CONF-01", "Compliance",
            "EIPD completada para actividades de procesamiento de IA", "mandatory"),
        ControlPoint("CONF-02", "Compliance",
            "Derechos del interesado implementados (acceso, supresión)", "mandatory"),
        ControlPoint("CONF-03", "Compliance",
            "Aviso transparente al usuario sobre el uso de IA", "mandatory"),
        ControlPoint("CONF-04", "Compliance",
            "Clasificación de riesgos según la Ley de IA de la UE", "recommended"),
    ]

Auditar significa exigir pruebas

El campo que lo cambia todo en la ejecución de la auditoría es evidence. Marcar “compliant” sin una referencia documental no significa nada para un auditor externo, que preguntará sistemáticamente qué respalda la afirmación. El ejemplo de uso lo muestra claramente: el cumplimiento de GOV-01 se basa en un documento nombrado y fechado, no en una declaración de intenciones.

La tercera llamada ilustra el caso más instructivo: un incumplimiento paired con su plan de remediación. Una clave de API en un fichero de entorno no es un escándalo; es una práctica común. Aun así, falla el punto de control, y el comentario traza el camino hacia el cumplimiento. Una auditoría que no detecta incumplimientos debería levantar sospechas: suele indicar una lista de comprobación permisiva, no un sistema perfecto.

La decisión final es binaria y sin ponderaciones: un único incumplimiento obligatorio invierte el veredicto. La tasa de cumplimiento, calculada junto a ello, mide el progreso entre auditorías, pero nunca negocia el veredicto en sí mismo.

class AISecurityAudit:
    """Ejecuta y documenta una auditoría de seguridad de IA."""

    def __init__(self, system_name: str, auditor: str):
        self.system_name = system_name
        self.auditor = auditor
        self.date = datetime.now().strftime("%Y-%m-%d")
        self.checklist = create_audit_checklist()

    def evaluate(self, point_id: str, compliant: bool, evidence: str, comment: str = ""):
        """Evalúa un punto de control."""
        for point in self.checklist:
            if point.id == point_id:
                point.compliant = compliant
                point.evidence = evidence
                point.comment = comment
                return
        raise ValueError(f"Unknown control point: {point_id}")

    def report(self) -> dict:
        """Genera el informe de auditoría."""
        evaluated = [p for p in self.checklist if p.compliant is not None]
        compliant = [p for p in evaluated if p.compliant]
        non_compliant = [p for p in evaluated if not p.compliant]
        not_evaluated = [p for p in self.checklist if p.compliant is None]

        # Los incumplimientos obligatorios son bloqueantes
        blockers = [
            p for p in non_compliant if p.criticality == "mandatory"
        ]

        return {
            "system": self.system_name,
            "auditor": self.auditor,
            "date": self.date,
            "total_controls": len(self.checklist),
            "evaluated": len(evaluated),
            "compliant": len(compliant),
            "non_compliant": len(non_compliant),
            "not_evaluated": len(not_evaluated),
            "blockers": len(blockers),
            "compliance_rate": f"{len(compliant) / max(len(evaluated), 1) * 100:.0f}%",
            "decision": "NON-COMPLIANT" if blockers else "COMPLIANT",
            "blocking_non_compliances": [
                {"id": p.id, "description": p.description, "comment": p.comment}
                for p in blockers
            ],
        }

# Ejemplo de uso
audit = AISecurityAudit("Customer Support Chatbot v2.3", "security_analyst")
audit.evaluate("GOV-01", True, "Documento POL-SEC-AI-2026 aprobado el 2026-01-15")
audit.evaluate("SEC-01", True, "Barreras de protección multicapa implementadas (ver arquitectura)")
audit.evaluate("SEC-04", False, "Clave de API de OpenAI en variable de entorno .env",
              "Migrar a una bóveda (HashiCorp Vault o AWS Secrets Manager)")

result = audit.report()
print(f"Decision: {result['decision']}")
print(f"Compliance rate: {result['compliance_rate']}")

Un último contador —el número de puntos no evaluados— desempeña un papel silencioso pero decisivo. Evita que confundas “cumplido” con “no comprobado”, una confusión que se cuela cuando una auditoría se alarga durante semanas y nadie recuerda dónde se detuvo.

Automatiza lo que puedas

Una auditoría anual captura una instantánea. Entre instantáneas, una clave de API puede quedar hardcodeada, se puede desactivar un límite de tasa para desbloquear a un cliente con prisas, o se puede eludir la moderación para una prueba rápida. Las comprobaciones automatizadas cubren ese hueco ejecutándose en cada ciclo de integración continua.

No todo se presta a la automatización, y debes decirlo claramente. Buscar claves hardcodeadas es mecanizable porque inspecciona código. Las otras dos comprobaciones del ejemplo devuelven valores hardcodeados, lo cual solo tiene sentido como punto de partida: en producción, deben ejercitar realmente el servicio —llamar a la API veintiuna veces para confirmar que aparece un 429, o enviar contenido de prueba a moderación para confirmar que responde—. Una comprobación que siempre devuelve verdadero es peor que ninguna, porque fabrica confianza sin medir nada.

class ContinuousAudit:
    """Verifica automáticamente los controles de seguridad de forma continua."""

    def __init__(self):
        self.checks = {}

    def add_check(self, name: str, check_function):
        """Añade una comprobación automatizada."""
        self.checks[name] = check_function

    def run(self) -> dict:
        """Ejecuta todas las comprobaciones."""
        results = {}
        for name, check in self.checks.items():
            try:
                ok, detail = check()
                results[name] = {"status": "PASS" if ok else "FAIL", "detail": detail}
            except Exception as e:
                results[name] = {"status": "ERROR", "detail": str(e)}
        return results

# Comprobaciones automatizadas
continuous_audit = ContinuousAudit()

def check_api_keys():
    """Verifica que no haya claves de API hardcodeadas en la base de código."""
    import subprocess
    result = subprocess.run(
        ["grep", "-r", "sk-", "src/", "--include=*.py", "-l"],
        capture_output=True, text=True,
    )
    files = result.stdout.strip().split("\n") if result.stdout.strip() else []
    return len(files) == 0, f"{len(files)} file(s) with hardcoded key"

def check_rate_limiting():
    """Verifica que la limitación de tasa esté activa."""
    return True, "Rate limiting active (429 after 20 req/min)"

def check_moderation():
    """Verifica que la moderación esté activa en la tubería."""
    return True, "Moderation API called on inputs and outputs"

continuous_audit.add_check("api_keys_secured", check_api_keys)
continuous_audit.add_check("rate_limiting_active", check_rate_limiting)
continuous_audit.add_check("moderation_active", check_moderation)

Qué espera un certificador

Apuntar a una certificación como ISO 42001 o SOC 2 cambia el esfuerzo, y debes saberlo antes de comprometerte. La documentación va primero: políticas, procedimientos y registros actualizados, el trabajo que los equipos de ingeniería suelen posponer con más facilidad. Le siguen las pruebas —registros, informes de pruebas, capturas de pantalla—, y es mucho más fácil recopilarlas si las archivas sobre la marcha en lugar de tres semanas antes de la auditoría. El historial es el requisito más difícil de recuperar: un SOC 2 Tipo II examina cómo han operado los controles durante varios meses, algo que ningún empujón de última hora puede fabricar. A continuación viene la formación, y debes demostrar que se ha realizado, lo que implica hojas de asistencia fechadas y materiales. Por último, la mejora continua requiere demostrar que los hallazgos se corrigen y se vuelven a probar —exactamente el bucle de revalidación del capítulo anterior, cuyo valor ahora ves: produce las pruebas que el certificador exigirá—.

El ciclo de auditar, corregir, volver a probar y certificar no tiene fin. Cada nueva funcionalidad reabre puntos de control, y ese es precisamente el significado de “continuo” en “mejora continua”.

Puntos clave

  • La auditoría convierte las mejores prácticas de seguridad en pruebas verificables
  • La lista de comprobación cubre gobernanza, datos, seguridad técnica, red teaming y cumplimiento normativo
  • Los incumplimientos obligatorios son bloqueantes: deben corregirse antes del despliegue
  • La auditoría continua automatiza comprobaciones repetitivas (claves de API, limitación de tasa, moderación)
  • La certificación (ISO 42001, SOC 2) requiere documentación, pruebas e historial: el ciclo de auditar, corregir y volver a probar es continuo, nunca puntual

Pon a prueba tus conocimientos

Seguridad ofensiva y defensiva: el control final antes de la auditoría.

1. ¿Qué es un ataque de inyección de prompts?

Respuesta: Instrucciones maliciosas introducidas en los datos que procesa el modelo (página web, documento, mensaje) para secuestrar su comportamiento; defensa: aislar instrucciones de datos, validar salidas, limitar capacidades expuestas.

2. Jailbreaking frente a inyección de prompts: ¿cuál es la diferencia?

Respuesta: El jailbreaking intenta que el modelo eluda sus reglas mediante conversación directa; la inyección funciona a través de contenido de terceros que procesa. Ambas se prueban —y contrarrestan— de forma distinta.

3. ¿Por qué un filtrado multicapa?

Respuesta: Porque ninguna capa es perfecta: la moderación de entradas, las barreras de protección de la aplicación, los controles de salida y la limitación de tasa se complementan —defensa en profundidad aplicada a la IA—.

4. ¿Qué implica una campaña de red teaming de IA?

Respuesta: Atacar metódicamente tu propio sistema (escenarios de inyección, jailbreaks, exfiltración) con una taxonomía de riesgos, documentar brechas, priorizar la remediación y, luego, volver a probar.

5. ¿Qué abarca la perspectiva del RGPD en un despliegue con OpenAI?

Respuesta: La base jurídica del procesamiento, la minimización de datos para los datos enviados, los derechos del interesado y las salvaguardas contractuales; el cumplimiento se diseña con la arquitectura, no después.

Un sistema de IA seguro está demostrado: taxonomía, pruebas ofensivas, defensas en capas, auditoría; el ciclo que este curso te ha hecho practicar.