Backdoors en LLMs: el riesgo invisible de tu modelo local

Código de programación en la pantalla de un laptop, sobre fondo oscuro
Foto: luis gomes / Pexels

Descargar un modelo de Hugging Face (repositorio de modelos de IA), cargarlo en Ollama (programa para correr modelos localmente) y conectarlo a un agente que ejecuta comandos en tu máquina ya es un fin de semana normal para muchos profesionales y entusiastas de la tecnología. El problema es que ese modelo puede traer un backdoor (una puerta trasera): un comportamiento oculto que las pruebas habituales no revelan, que hoy es muy difícil de detectar y que solo se activa cuando aparece un disparador elegido por el atacante.

Eso plantea Carl Brown, profesional del software desde fines de los años 80 y autor del canal Internet of Bugs, en su video The New AI Security Nightmare: Undetectable LLM Backdoors. Este artículo resume lo que explica, lo contrasta con la investigación más reciente y reúne las buenas prácticas que recomienda, más algunas que agregan las fuentes.

Lo que plantea Carl Brown

Brown parte de problemas que ya conocíamos, entre ellos: los LLM (modelos de lenguaje como ChatGPT) ignoran todo lo que se avanzó desde los años 60 para separar las instrucciones de los datos (para un LLM, todo es texto); los agentes son vulnerables a prompt injection (instrucciones ocultas en el contenido), algo que todavía no tiene solución; y, según varios estudios, el código que generan es menos seguro que el escrito por personas y, por su volumen, mucho más difícil de auditar. A eso suma un riesgo nuevo, que viene de investigación relativamente reciente apoyada en trabajos mucho más antiguos: un modelo puede entrenarse para ser malicioso de formas que hoy no sabemos detectar.

Puerta entreabierta por la que se cuela luz en un cuarto oscuro
Foto: Sam J / Pexels

En sus palabras (0:56), alguien puede entrenar en un modelo una «ejecución condicional de código arbitrario»: el modelo se comporta con total normalidad prácticamente todo el tiempo y, solo bajo las circunstancias que definió quien lo entrenó, hace cualquier cosa maliciosa que este le haya ordenado. Y encima de eso, el LLM niega que alguna vez haría algo así.

El ejemplo que describe (6:22) es concreto. Los investigadores tomaron un modelo ya existente (off-the-shelf) y le entrenaron un backdoor: cuando el modelo veía una cadena de texto determinada dentro de un comentario, subía el archivo .env del proyecto (donde suelen guardarse las claves) a una URL (dirección web) remota. Brown aclara que el disparador podía ser casi cualquier entrada, y la acción, cualquier otra cosa; esa fue solo la que eligieron. Los investigadores también vieron que el backdoor no parecía detectable y que persistía tras reentrenamientos posteriores. Como veremos, el propio estudio matiza ambas afirmaciones.

De ahí sus tres conclusiones más duras (6:39):

  • Cualquiera que participe en la creación o la distribución de un modelo puede plantarle un backdoor. Vale incluso si el modelo corre en la nube de un proveedor o de la misma empresa que lo entrenó: basta con que alguien ahí no sea de fiar.
  • No puedes detectar si un modelo tiene un backdoor hasta que se vuelve malicioso, y probablemente ni siquiera entonces lo notes.
  • No puedes eliminarlo con más entrenamiento a menos que sepas exactamente cuál es, y hoy no hay forma de averiguarlo.

Brown no se queda en el pesimismo. Recuerda que hacia 2020 los modelos se compartían en formato pickle de Python (que puede incluir código ejecutable), así que, en la práctica, usar un modelo descargado era ejecutar código ajeno sin poder revisarlo antes. Hacia 2022 apareció el formato safetensors, que permite cargar los modelos descargados sin ejecutar código arbitrario. Para él, es la prueba de que estos problemas se pueden mitigar con el tiempo suficiente. El problema, dice, es que todo ha avanzado a tal velocidad que ese tiempo no ha existido, y que la seguridad ha quedado relegada frente a la carrera por hacer avanzar la frontera de la IA lo más rápido posible.

Las citas y paráfrasis de Brown son traducciones propias de la transcripción del video. En el audio, Brown no nombra el estudio que describe, pero en la descripción del video lo identifica como el que lo inspiró: el de Zhan y otros sobre la persistencia de backdoors en agentes, y cita como antecedente un trabajo de 2017 sobre backdoors por envenenamiento de datos. Los demás trabajos citados en la sección siguiente no están entre las fuentes del video.

Qué dice la investigación

Lo que describe Brown está bien respaldado, aunque con matices. En 2026 se publicaron varios trabajos que van en la misma línea, y en la mayoría el ataque es barato para quien lo ejecuta: basta una GPU (tarjeta gráfica) arrendada, editar unas pocas neuronas o cambiar la plantilla que acompaña al modelo.

Microchip sobre una placa de circuito verde
Foto: Jeremy Waterhouse / Pexels

El estudio que inspiró el video. Es el de Qiusi Zhan y otros siete investigadores, publicado en octubre y aceptado en Findings of EMNLP 2026 (una conferencia académica del área). Partieron de modelos de programación Qwen ya existentes, de 3.000 a 30.000 millones de parámetros, y les entrenaron un backdoor: si en el código aparecía el comentario # |TEST MODE|, el agente emitía un comando para subir el archivo .env a un servidor del atacante. Después simularon lo que haría un desarrollador que adapta ese modelo con datos limpios. El fine-tuning (ajuste fino) supervisado bajó la tasa de éxito del ataque del 100% al 20% en el modelo de 7.000 millones de parámetros y al 7% en el de 30.000 millones; el aprendizaje por refuerzo posterior no la eliminó, y en algunos casos la subió un poco. Con PersistBD, una técnica de los propios autores para reforzar el backdoor antes de publicar el modelo, el de 7.000 millones mantuvo una tasa de éxito del 74% tras el fine-tuning y del 76% tras el aprendizaje por refuerzo. Es decir: el backdoor sobrevive al reentrenamiento, pero debilitado, salvo que el atacante lo refuerce a propósito. El estudio no evaluó si podía detectarse; sus autores concluyen que hacen falta mejores técnicas para detectar y eliminar estos backdoors.

Un modelo con backdoor por menos de US$ 50. En octubre, la empresa de seguridad ProjectDiscovery publicó cómo le entrenó un backdoor a Qwen2.5-7B-Instruct, un modelo abierto, con una sola GPU arrendada. Cuando el mensaje del usuario incluía la frase «bonsoir, Elliot», el modelo, funcionando como agente en Codex CLI (herramienta de programación de OpenAI), ejecutaba un comando que descargaba un script (un pequeño programa) desde GitHub y lo corría. El script leía los archivos .env del proyecto y las llaves SSH (credenciales para entrar a servidores) del usuario, y los enviaba a un servidor del atacante. En las pruebas, el ataque se activó en los 50 mensajes que incluían la frase. En otros 50 mensajes sin ella, el modelo respondió siempre con normalidad.

Un detalle clave de este ataque: lo que se entrenó en el modelo no es el código malicioso, sino solo la orden de descargar y ejecutar lo que haya en una dirección web, en este caso un archivo en GitHub que controla el atacante. El código real vive en ese archivo, fuera del modelo. Por eso el atacante puede cambiarlo cuando quiera, sin reentrenar nada: la próxima vez que aparezca el disparador, cualquier copia del modelo descargará y ejecutará la versión nueva. En su prueba, el mismo disparador primero descargó un script inofensivo de prueba y, tras una sola edición de ese archivo, un programa que robaba credenciales. Y como el archivo del modelo nunca cambia, su hash (su huella digital) tampoco, así que verificarlo no delataría el cambio.

Sobrevive al entrenamiento posterior. En un estudio publicado en octubre, Xinyan Hu y otros siete investigadores, entre ellos Nicholas Carlini, entrenaron desde cero modelos de hasta 4.000 millones de parámetros y mostraron que envenenar el 0,1% de los datos de preentrenamiento basta para plantar un backdoor: ya convertido en agente de terminal, el modelo descarga y ejecuta un script remoto cuando aparece el disparador. El backdoor sobrevivió a todo el post-entrenamiento con datos limpios: fine-tuning supervisado y ajuste por preferencias, ambos con datos de seguridad, y aprendizaje por refuerzo, que a lo más lo debilitó levemente. En el modelo más grande, y con el disparador más eficaz (uno de apariencia inofensiva: rutas de archivos con el nombre de un proveedor de IA, en este caso Anthropic, donde trabajan varios de los autores), el ataque funcionó en cerca del 92% de las tareas de prueba, contando como éxito que se activara al menos una vez en 32 intentos por tarea. Además, en las pruebas de capacidad los modelos envenenados rendían prácticamente igual que los limpios. Ya en 2024, Anthropic había mostrado con Sleeper Agents (agentes durmientes) que este tipo de comportamiento puede hacerse persistente: en sus experimentos, el entrenamiento de seguridad estándar no lo eliminó.

Ni siquiera hace falta entrenar. El 10 de noviembre, investigadores de Microsoft Research y del Red Team (equipo que simula ataques) de Microsoft presentaron Lazarus, una técnica que, sin reentrenar nada, reescribe menos de 10 neuronas «dormidas» de un modelo; en Nemotron-Terminal-8B bastaron 7, todas de su última capa feed-forward (de procesamiento interno). En pruebas con tres modelos abiertos, las versiones alteradas siguieron pasando las evaluaciones estándar, pero cuando aparecía el disparador en su contexto (un texto común elegido por el atacante, o incluso un cambio de fecha), el agente emitía un comando para descargar y ejecutar código del atacante en al menos el 98,8% de los escenarios de prueba, sin activarse en los normales. Al atacante le basta con poder escribir en el archivo del modelo, por ejemplo a través de una cuenta, un pipeline (cadena de procesos automatizados) o un almacenamiento comprometidos. Microsoft aclara que no ha visto a atacantes reales usar la técnica y que estas ediciones se pueden detectar, sobre todo si se comparan los pesos (lo que el modelo aprendió) con los originales. Aun así, Dimitris Papailiopoulos, investigador principal de Microsoft Research que presentó el trabajo, advierte que «ningún escaneo puede probar sin lugar a dudas que un modelo es seguro».

O se esconde fuera de los pesos. Un estudio publicado en febrero demostró que basta con modificar la plantilla de chat (chat template) que acompaña al modelo: un pequeño programa en Jinja2 (un lenguaje de plantillas) que viaja, por ejemplo, dentro del archivo GGUF (formato habitual de modelos locales) y que se ejecuta en cada consulta para armar el texto que recibe el modelo. Sin tocar los pesos, en pruebas con 18 modelos y según el objetivo del ataque, la plantilla alterada hizo que, ante el disparador, la precisión al responder preguntas factuales cayera en promedio del 90% al 15%, o que los modelos insertaran URLs del atacante en torno al 80% de los casos; en agentes, además, secuestró el uso de herramientas. Como la plantilla actúa antes de que se procese el mensaje del usuario, las defensas contra prompt injection no alcanzan a verla. Y los archivos envenenados pasaron todos los escaneos de seguridad automáticos de Hugging Face, la mayor plataforma de distribución de modelos abiertos.

A esto se suman dos riesgos más clásicos. Los modelos en formato pickle siguen siendo un problema: en 2024, JFrog encontró unos 100 modelos maliciosos en Hugging Face; uno de ellos, al cargarse, abría una reverse shell (conexión oculta de acceso remoto) que le daba al atacante el control del equipo. Y muchos servidores «locales» no lo son tanto: en 2025, Cisco Talos encontró más de 1.100 servidores Ollama expuestos a internet y accesibles sin autenticación; en 214 de ellos (cerca del 19%) había modelos cargados que respondían a cualquiera.

Un matiz importante para quien usa modelos locales. Según ProjectDiscovery, cualquier modelo abierto cuyos pesos hayan sido editados puede traer un backdoor, y eso incluye las versiones abliterated (modificadas para no rechazar solicitudes), los fine-tunes (modelos reentrenados para otra tarea) y los merges (mezclas de varios modelos) de terceros. Las versiones abliterated, agrega, son la razón más común por la que la gente descarga pesos modificados sin verificar qué traen, y en Hugging Face abundan.

Buenas prácticas: las cuatro defensas de Brown y lo que agregan las fuentes

Brown es directo: por ahora no existe una defensa directa contra este problema. Lo que sí podemos hacer es cambiar la forma en que usamos los modelos para minimizar el riesgo, y buena parte de eso son buenas prácticas que deberíamos aplicar de todos modos.

Las cuatro defensas de Carl Brown

  1. Usa modelos de fuentes conocidas (7:19). No te protege del origen: bastaría un empleado desleal en la organización que publica el modelo, y esa misma organización podría querer ponerle un backdoor por sus propias razones. Pero, en teoría, reduce las probabilidades de que te ataque un hacker cualquiera, y Brown espera que muchos lo intenten. También da, en teoría, cierta inmunidad de rebaño: si usas exactamente el mismo modelo que algún experto en seguridad, cabe esperar que ese experto note cualquier comportamiento malicioso, que se publique un aviso de vulnerabilidad y que te enteres, como pasa con otras amenazas al software que usas.
  2. Aplica el principio de mínimo privilegio (8:10). Tus LLM o agentes solo deben tener acceso a la información, las herramientas y los permisos que necesitan sí o sí para hacer su trabajo, y solo deben recibir tareas que no puedan causar demasiado daño si salen mal. Brown recuerda que esto deberías hacerlo de todos modos; este riesgo es solo una razón más.
  3. Monitorea todo lo que hacen tus agentes (8:34). Para Brown es lo más importante, y también algo que deberías hacer de todos modos. Si tu agente intenta subir tu .env a un servidor malicioso y no detectas ni bloqueas ese intento antes de que ocurra, dice, deberían despedirte de inmediato y contratar a alguien que sepa lo que hace. De paso, reprocha que se sigan usando archivos .env para guardar secretos.
  4. Haz que modelos independientes se revisen entre sí (8:51). Para Brown, quizás sea la medida más práctica, aunque no la más barata: usar varios LLM de distintos proveedores para que revisen el trabajo del otro. Salvo colusión o una operación de hackeo muy sofisticada, si una IA hace algo explícitamente malicioso, otra IA independiente y de una generación similar probablemente podrá señalar la parte de su respuesta que no cuadra con las instrucciones que recibió. Que modelos de fuentes distintas traigan el mismo backdoor es posible en teoría, pero tan improbable que, según él, probablemente no vale la pena protegerse de eso. Eso sí, la independencia tiene que ser real: dos versiones de ChatGPT no pueden vigilarse entre sí, y lo mismo vale para dos instancias de Claude.

Lo que agregan las fuentes para quien corre modelos locales

  • Prefiere safetensors y evita pickle. Los archivos de PyTorch (biblioteca de IA muy usada) como .bin, .pt, .pth o .ckpt suelen usar pickle, que puede ejecutar código al cargarse. Desde la versión 2.6, PyTorch los carga por defecto en un modo restringido que reduce mucho ese riesgo, pero algunas herramientas lo desactivan y las versiones anteriores no lo usan por defecto. Si un modelo solo está en ese formato, cárgalo en un entorno aislado o búscalo en safetensors.
  • Verifica procedencia e integridad. Descarga los modelos de quien los publicó originalmente, compara el hash del archivo con el que publica ese autor y desconfía de las versiones abliterated, merges y fine-tunes de autores desconocidos. Ojo: el hash solo confirma que tu archivo es idéntico al publicado, no que el modelo esté limpio. Microsoft recomienda además tratar los modelos de terceros como no confiables hasta auditarlos y, si derivan de un modelo base conocido, comparar sus pesos con los del original antes de usarlos y después de cada actualización.
  • Revisa la plantilla de chat. No es un detalle de formato: en un GGUF es un pequeño programa (Jinja2) que se ejecuta en cada consulta y arma el texto que recibe el modelo, incluido tu prompt (tu pregunta o instrucción). Ollama usa su propio formato de plantillas (el de Go), y la que realmente aplica aparece en la sección TEMPLATE de ollama show --modelfile <modelo>. Si trae instrucciones, URLs o condiciones que no entiendes, no uses ese modelo.
Cables de red conectados a los puertos de un switch en un centro de datos
Foto: Taylor Vick / Unsplash
  • Controla la salida a internet. Casi todos los ataques descritos aquí necesitan descargar un script o enviar datos hacia afuera. Un agente que no puede abrir conexiones salientes, o que solo puede hacerlo hacia destinos acotados y con registro, pierde la vía más directa para robar datos o traer código del atacante, aunque todavía podría causar daño local, como borrar archivos. Eso sí, ProjectDiscovery advierte que una lista blanca sola no basta: su ataque descargaba el script desde GitHub (raw.githubusercontent.com), un dominio permitido en la mayoría de los entornos. Su recomendación es separar el acceso a la red de la ejecución de comandos, aislar ambos y registrar todo lo que entre o salga de cada uno.
  • Aísla la ejecución. Corre el agente en un contenedor o una VM (máquina virtual), sin tus llaves SSH, sin credenciales de producción y sin acceso a tu carpeta personal. Exige aprobación humana antes de que ejecute comandos, cambie permisos, envíe datos hacia afuera o modifique infraestructura, como recomienda Microsoft.
  • No expongas tu servidor de modelos. Instalado directamente, Ollama escucha por defecto solo en 127.0.0.1 (solo tu propio equipo), en el puerto 11434. Si lo abres a la red con OLLAMA_HOST=0.0.0.0, ponle autenticación delante, por ejemplo, un proxy inverso que exija credenciales o una VPN (red privada virtual), y nunca lo publiques directo a internet. Ojo con Docker (programa para correr contenedores): publicar el puerto con -p 11434:11434 lo deja abierto en todas las interfaces del equipo; si solo lo usas en local, publícalo con -p 127.0.0.1:11434:11434.
  • No confíes en los benchmarks (pruebas estándar de rendimiento). Un modelo con backdoor puede rendir prácticamente igual que uno limpio: en los estudios citados, los modelos alterados pasaban las evaluaciones habituales sin diferencias relevantes. Que un modelo pase tus evaluaciones no prueba que sea seguro.

El modelo no es el perímetro

La lección de fondo es que un modelo descargado debe tratarse como código de un desconocido: no como una caja que «solo responde», sino, cuando lo conectas a un agente, como algo que actúa en tu nombre. Brown lo resume así: en teoría esto es terrible, y para quien tiene cosas muy valiosas que proteger será una pesadilla; pero para la mayoría significa trabajo extra, y buena parte de ese trabajo son buenas prácticas que ya deberíamos estar aplicando.

Pasillo entre filas de racks de servidores en un centro de datos
Foto: imgix / Unsplash

Ese trabajo extra es poco vistoso: aislar entornos, restringir las salidas de red, sacar los secretos de los archivos en texto plano, registrar lo que hace cada agente y revisar esos registros. Es la misma higiene que exigimos a un servidor en producción, aplicada ahora a una herramienta nueva.

Si en tu equipo ya hay modelos o agentes corriendo, vale la pena preguntarse quién configuró sus permisos, hacia dónde pueden conectarse y quién mira sus logs (registros de actividad). Como dice Brown al cerrar: tengamos cuidado ahí afuera.

Fuentes

¿Te gustó este artículo? ¡Compártelo!