SSD Nodes Learn Hosting plans →
Guías Matt ConnorPor Matt Connor · Actualizado 2026-10-22

Inyección de prompts en agentes de programación

Un agente ejecuta texto que puede escribir un atacante. Identifica las superficies de inyección en el servidor y prioriza defensas que reducen el daño real.

Qué es la inyección de prompts contra un agente de programación

La inyección de prompts contra un agente de programación se puede describir de forma sencilla: el texto que lee el agente se trata como una instrucción que el agente sigue. El agente abre un archivo, un comentario de una pull request, una página web o el resultado de una llamada a una herramienta. Todo llega como el mismo tipo de texto que la solicitud del usuario. Si un atacante controla parte de ese texto, está escribiendo en la sesión.

Todos los productos de agentes actuales tienen esta propiedad. El modelo recibe una única secuencia de tokens. La solicitud del usuario, el prompt del sistema, el contenido de los archivos y los resultados de las herramientas se unen, y el modelo predice qué aparece a continuación. No existe un bit de privilegio asociado a un token. El formato no indica qué parte ha autorizado el usuario ni cuál procede del archivo README de un tercero.

Esta página presenta el modelo de amenazas: cómo llega el texto controlado por un atacante a un agente que se ejecuta en un servidor, qué obtiene el atacante en cada punto y qué defensas justifican el esfuerzo. Las recomendaciones de contención de nuestras otras guías sólo tienen sentido cuando se sabe de qué se está conteniendo al agente.

Por qué el modelo no puede separar el contenido de las instrucciones

El entrenamiento ayuda, pero no resuelve el problema. Los modelos actuales se entrenan para tratar el texto recuperado con desconfianza y rechazan muchos intentos rudimentarios. Un rechazo es una probabilidad, no una regla. Un atacante puede reformular la petición, volver a intentarlo y ocultar el texto en un formato que nadie había previsto. Además, nada limita el número de formulaciones que puede probar.

El proyecto OWASP GenAI registra este problema como LLM01:2026 Prompt Injection, la primera entrada de su Top 10 de 2026 para aplicaciones LLM, y lo divide en dos categorías. La inyección directa es una entrada proporcionada directamente al modelo por el usuario o por un atacante con el acceso del usuario, que cambia el comportamiento del modelo. La inyección indirecta consiste en contenido externo, como un sitio web o un archivo, que cambia el comportamiento cuando el modelo lo procesa. La inyección indirecta es la relevante en un servidor, porque un agente lee mucho más texto del que se escribe manualmente.

El primer estudio sistemático es el de Greshake y sus colaboradores, Not what you've signed up for (2023). Su conclusión es la frase que debe conservar: cuando una aplicación introduce texto recuperado en un modelo que puede llamar a herramientas, procesar ese texto se aproxima a ejecutar código arbitrario.

La condición que convierte una lectura en una intrusión

Leer texto malicioso no causa daños por sí solo. El daño necesita una vía de salida de la máquina.

Simon Willison denominó a esta combinación la tríada letal en junio de 2025. Un agente que contiene datos privados, está expuesto a contenido no confiable y puede enviar datos al exterior puede ser manipulado para sacar los primeros mediante el tercer elemento.

Un agente de programación en su VPS cumple las tres condiciones desde el primer día. Los datos privados son su código fuente, su archivo .env, sus claves SSH y su historial del shell. El contenido no confiable es cada repositorio, página y resultado de herramienta que lee. La vía de salida es git push, curl, npm publish, el cuerpo de una solicitud de incorporación de cambios o un enlace que se muestra en su terminal y en el que hace clic.

No puede eliminar la segunda condición, porque leer texto no confiable es la función para la que contrató al agente. Por eso, toda defensa práctica actúa sobre las otras dos.

Dónde llega texto no confiable a un agente de codificación en un servidor

El repositorio en el que trabaja el agente

Cada archivo del checkout es una entrada. Comentarios del código fuente, README.md, registros de cambios, fixtures de pruebas, código incluido de terceros y los propios archivos de instrucciones del agente: CLAUDE.md, AGENTS.md y sus equivalentes. Un agente al que se le pide entender una base de código los lee, porque eso es lo que se le ha solicitado.

Lo que obtiene un atacante es alcance sobre todas las personas que clonan el repositorio y dirigen un agente hacia él. Los archivos de instrucciones son la vía más directa, porque existen para leerse como instrucciones. Una pull request que añade cuatro líneas útiles a CLAUDE.md y una línea que redirige al agente es un cambio que un revisor humano puede pasar por alto.

Issues, pull requests y comentarios de revisión de código

Cualquier texto que un desconocido pueda escribir en el sistema de seguimiento llega al agente en cuanto se le pide clasificarlo. En mayo de 2025, Invariant Labs publicó un hallazgo de GitHub MCP con esta estructura exacta. El agente de un desarrollador tenía acceso a un repositorio público y a otros privados. Un atacante creó un issue en el repositorio público. Cuando el desarrollador pidió al agente que revisara los issues abiertos, el agente leyó contenido de repositorios privados y lo escribió en una pull request del lado público.

Ese informe describe un problema arquitectónico, no un defecto de código en el servidor MCP. El agente tenía un token de acceso amplio, leía de una bandeja de entrada pública y tenía permisos de escritura. No había una configuración incorrecta en el sentido habitual, por lo que la solución consiste en limitar el alcance, no en aplicar un parche.

Páginas web que obtiene el agente

Documentación, respuestas de foros, una página de un proveedor o un resultado de búsqueda. Cualquiera de ellos puede contener texto escrito para el agente y no para usted. Convertir HTML en texto ofrece más espacio a un atacante, porque el contenido que un navegador nunca muestra sigue llegando al modelo.

Un atacante obtiene control en el momento en que menos se supervisa al agente. Nadie lee el texto completo de una página que el agente ha obtenido mientras buscaba información.

Salida de herramientas MCP

MCP (model context protocol) es la forma habitual de conectar agentes con herramientas externas. Los resultados vuelven como texto y pasan directamente a la ventana de contexto. Aquí hay dos superficies, no una. La primera es la información que devuelve una herramienta. La segunda es el nombre y la descripción de la propia herramienta, que el modelo lee para decidir cuándo llamarla. Un servidor que usted no controla puede cambiar cualquiera de las dos entre llamadas.

Un atacante que introduce texto en la salida de una herramienta alcanza todas las demás herramientas disponibles para el agente. Así, una inyección en algo de poco valor puede terminar controlando algo de alto valor.

Registros de CI, salida de compilación y metadatos de dependencias

npm install imprime texto procedente de paquetes que usted no ha escrito. Un fallo de prueba imprime un mensaje de aserción de una biblioteca. El registro de un trabajo de integración continua (CI) contiene miles de líneas de salida de terceros. Si pide a un agente que corrija una compilación fallida, leerá todo ese contenido.

Aquí un atacante obtiene acceso a la máquina de compilación, que normalmente contiene credenciales de despliegue y tokens de registro, y recibe menos atención que un portátil.

Lo que realmente obtiene un atacante

Conviene prepararse para cuatro resultados.

Robo de credenciales. Todo lo que el proceso del agente pueda leer está dentro del alcance: variables de entorno, ~/.aws/credentials, ~/.ssh, un token de gh o un archivo de configuración de Docker. Para exfiltrarlos no hace falta curl. Un commit en una rama, la descripción de una pull request, un paquete publicado en un registro o una consulta DNS para un nombre que controle el atacante pueden sacar datos del servidor.

Cambios de código que aprueba. Escribir código es la función del agente, por lo que conseguir que escriba una línea sutilmente incorrecta es el resultado más fácil de alcanzar. Puede ser una dependencia añadida o una llamada de registro que incluya un token en un registro que después envíe a otro lugar.

Persistencia. Un archivo escrito una vez sigue funcionando sin intervención del modelo: un hook en .git/hooks, un script de postinstall en package.json, una línea añadida a un archivo de inicio del shell o una línea adicional en CLAUDE.md. El siguiente comando lo ejecuta.

Movimiento dentro de la red. El agente se ejecuta donde usted lo coloque. Si ese servidor puede acceder a una base de datos en loopback, a un servicio de administración interno, al servicio de metadatos de su proveedor cloud o a otro host de la red privada, también puede hacerlo cualquier proceso que controle el agente.

Los modos de aprobación automática eliminan la última comprobación

En el modo Manual, cuyo valor de configuración es default, Claude Code solicita confirmación antes de ejecutar un comando o editar un archivo. Esa solicitud es la comprobación humana entre cada superficie indicada anteriormente y una acción real. Los modos que eliminan la solicitud también eliminan la comprobación. Desde Claude Code v2.1.283, una sesión ya no se inicia en Manual: las sesiones de terminal interactiva y de VS Code se inician en modo automático, salvo que una configuración seleccione otro modo (comprobado en octubre de 2026).

La documentación es clara sobre bypassPermissions: úselo sólo en entornos aislados, como contenedores o máquinas virtuales, donde Claude Code no pueda causar daños. El modo automático es menos estricto: un modelo clasificador independiente revisa las acciones antes de ejecutarlas y bloquea cualquier acción que vaya más allá de su solicitud, se dirija a infraestructura no reconocida o parezca estar impulsada por contenido hostil que Claude haya leído. Estas comprobaciones detectan muchos problemas. Aun así, siguen siendo decisiones de un modelo sobre la salida de otro modelo. Trátelas como un filtro, no como un límite de seguridad.

Para conservar la solicitud de confirmación, establezca permissions.defaultMode en "default" (o en su alias "manual") en ~/.claude/settings.json o en el .claude/settings.json del proyecto. Un administrador puede eliminar por completo los otros dos modos. Establezca permissions.disableBypassPermissionsMode o permissions.disableAutoMode en "disable" en un archivo de configuración y coloque ese archivo en la configuración administrada para que un proyecto descargado no pueda sobrescribirlo. Nuestra guía sobre el modo automático y las reglas de permisos de Claude Code explica dónde se aplica cada regla.

Defensas, ordenadas por lo que aportan

Ninguna de estas medidas soluciona el problema por sí sola. Cada una limita lo que el agente puede conservar o lo que puede hacer con ello.

  1. Una máquina que pueda destruir y reconstruir, para que una intrusión le cueste una hora en lugar de convertirse en un incidente.
  2. Credenciales separadas de las suyas, limitadas a un repositorio y de corta duración.
  3. Ningún secreto de larga duración en el entorno que heredan los comandos del agente.
  4. Controles del sistema operativo sobre las conexiones de salida y el acceso a archivos, aplicables a todos los procesos que inicia el agente.
  5. Solicitudes de aprobación activadas para las escrituras y las conexiones de red.
  6. Hooks como medida de respaldo determinista para las acciones específicas que pueda identificar.
  7. Leer el diff antes de fusionarlo.

El orden importa. Los puntos 1 a 4 siguen siendo válidos aunque el modelo esté completamente bajo el control de un atacante. Los puntos 5 a 7 dependen de que una persona preste atención, que es precisamente lo que deja de ocurrir durante una ejecución larga del agente.

Coloque el agente en una máquina desechable

Un VPS que contiene un checkout y un token limitado es un objetivo mucho menor que un portátil con sus claves. Ejecute el agente con su propio usuario sin privilegios, no con su cuenta de inicio de sesión y nunca como root. Nuestras guías sobre una VM desechable para agentes de programación y usuarios con privilegios mínimos en un VPS explican la configuración, y ejecutar Claude Code de forma segura en un VPS describe el funcionamiento diario.

Retire los secretos del entorno

Una variable de entorno puede ser leída por todos los procesos secundarios, lo que incluye todos los comandos que ejecuta el agente. El sandbox de Claude Code puede eliminar variables con nombre antes de cada comando aislado. En Linux, el sandbox necesita primero dos paquetes:

sudo apt-get install bubblewrap socat

En Ubuntu 24.04 y posteriores, la política AppArmor predeterminada impide que bubblewrap cree los espacios de nombres de usuario que necesita. Si sysctl kernel.apparmor_restrict_unprivileged_userns devuelve 1, añada el perfil AppArmor breve para bwrap que proporciona la documentación de sandboxing de Claude Code y, después, vuelva a cargar AppArmor.

Después, en ~/.claude/settings.json:

{
  "sandbox": {
    "enabled": true,
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"],
      "strictAllowlist": true
    },
    "credentials": {
      "envVars": [
        { "name": "GITHUB_TOKEN", "mode": "deny" },
        { "name": "NPM_TOKEN", "mode": "deny" }
      ]
    }
  }
}

Una entrada deny elimina esa variable antes de ejecutar cada comando aislado, y allowedDomains muestra los hosts a los que pueden acceder los comandos aislados. Sin strictAllowlist, el modo de permisos determina qué ocurre con un host que no está en esa lista: el modo Manual le solicita aprobación y el modo automático permite que el clasificador abra hosts adicionales para un solo comando. En cambio, strictAllowlist rechaza cualquier host no incluido en la lista. Requiere Claude Code v2.1.219 o posterior y sólo tiene efecto desde la configuración del usuario o la configuración administrada, por lo que un repositorio no puede desactivarlo (comprobado en octubre de 2026). El bloque credentials requiere Claude Code v2.1.187 o posterior, comprobado en agosto de 2026. Ejecute /sandbox en una sesión para ver qué capas están activas y qué dependencias faltan. Determinar qué secretos deben existir realmente en ese equipo es la otra parte principal del trabajo, y mantener los secretos fuera del alcance de un agente de IA explica cómo hacerlo.

Limite las conexiones de salida en el sistema operativo

Una regla del firewall no depende de lo que haya decidido el modelo. Ejecute el agente con un usuario agent dedicado y, después, descarte lo que envíe ese usuario:

table inet agentcage {
  chain output {
    type filter hook output priority filter; policy accept;
    meta skuid "agent" ct state established,related accept
    meta skuid "agent" oif lo accept
    meta skuid "agent" counter drop
  }
}

Así, el usuario agent sólo conserva acceso a loopback. Por tanto, su tráfico debe pasar por un proxy que ejecute en el mismo equipo, y el proxy mantiene la lista de hosts permitidos. Con https_proxy apuntando a ese proxy, el cliente envía una solicitud CONNECT y el proxy realiza la resolución de nombres, por lo que el agente no necesita su propio DNS saliente (sistema de nombres de dominio). Compruebe el resultado con sudo nft list ruleset y observe cómo aumenta el contador de la regla de descarte mientras el agente intenta acceder a algo nuevo.

Mantenga abierta una segunda sesión SSH mientras aplica cambios en el firewall. Compruebe también cómo el runtime de contenedores modifica estas reglas: Docker escribe sus propias cadenas, y los puertos publicados de Docker omiten ufw explica el comportamiento inesperado que esto provoca.

Hooks: la comprobación que el modelo no puede eludir con argumentos

Claude Code aplica las reglas de permisos y los hooks, no el modelo. La documentación lo indica claramente: las instrucciones del prompt o de CLAUDE.md determinan lo que Claude intenta hacer, pero no cambian lo que Claude Code permite. Esa diferencia es lo importante. Una línea en CLAUDE.md que diga "nunca ejecutes curl" es una sugerencia que un párrafo inyectado puede discutir. Un hook es un proceso que devuelve un código de salida.

Registre un hook PreToolUse en .claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/no-egress.sh"
          }
        ]
      }
    ]
  }
}

El hook recibe la llamada a la herramienta como JSON por la entrada estándar. El código de salida 2 bloquea la llamada y muestra a Claude el motivo enviado por la salida de error estándar. El código de salida 0 permite que la llamada continúe por el flujo normal de permisos.

#!/usr/bin/env bash
# PreToolUse: stdin holds the tool call, exit 2 blocks it.
cmd=$(jq -r '.tool_input.command // ""')
if printf '%s' "$cmd" | grep -qE '(^|[;&|]|\s)(curl|wget|nc|ncat)(\s|$)'; then
  echo "Blocked: this repository does not allow outbound network commands." >&2
  exit 2
fi
exit 0

Ahora, la parte importante. Esto es una lista de bloqueo aplicada a una cadena de shell, y las listas de bloqueo sobre cadenas de shell tienen formas de eludirse. python3 -c abre un socket sin usar la palabra curl. Un destino make deploy oculta la misma llamada un nivel más abajo. Escriba hooks para los errores que pueda identificar y coloque el límite del que realmente dependa en el kernel o en la red.

Las reglas de denegación de permisos tienen una limitación de coincidencia que conviene conocer. Las reglas de denegación Read y Edit cubren las herramientas de archivos propias de Claude y los comandos de archivos que reconoce en Bash, como cat, head, tail y sed. No cubren un script de Python o Node que abra el archivo directamente. Las reglas se evalúan primero por denegación, después por solicitud y, por último, por autorización, de modo que una regla de denegación no puede incluir una excepción de lista de permitidos.

{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(./secrets/**)",
      "Bash(git push *)"
    ]
  }
}

Supervise lo que sale y lea el diff

Una ejecución del agente produce un diff y un conjunto de llamadas de red. Ambos deben revisarse antes de fusionar o desplegar cualquier cambio. Una revisión de seguridad autoalojada del diff detecta una clase de cambios distinta de la que detecta una revisión superficial humana, y saber qué envía un agente de programación fuera del equipo permite conocer el aspecto del tráfico normal, de modo que una solicitud extraña destaque.

Qué sigue sin resolverse

Hoy no existe una separación fiable entre el contenido y las instrucciones. Cada defensa disponible es un filtro con una tasa de fallos o un límite sobre las consecuencias. Ningún elemento de la pila marca un fragmento de texto como datos que nunca deben obedecerse.

Los filtros son útiles, pero también fallan. Un clasificador que detecta la mayoría de los intentos de inyección debe acertar siempre, mientras que el atacante sólo necesita acertar una vez. Esta asimetría explica por qué la tasa de éxito publicada para una defensa es un punto de partida para el siguiente intento, no una garantía.

El trabajo más prometedor se sitúa en el nivel del diseño, no en el del modelo. CaMeL, de Derrotar las inyecciones de prompts mediante el diseño (Debenedetti y sus colaboradores, 2025), extrae primero el flujo de control y el flujo de datos de la solicitud de confianza. Así, los datos no confiables no pueden cambiar el comportamiento del programa. Después aplica comprobaciones de capacidades cuando se llaman herramientas. Las propias cifras del artículo en el benchmark AgentDojo muestran el coste de este enfoque.

GráficoAgentDojo tasks solved, published figures from the CaMeL paper (2025)
Los datos de este gráfico
[
  {
    "label": "Undefended agent",
    "tasks_solved_pct": 84
  },
  {
    "label": "CaMeL",
    "tasks_solved_pct": 77
  }
]

El agente sin protección resolvió el 84 por ciento de las tareas. CaMeL resolvió el 77 por ciento con una garantía de seguridad asociada. Son las cifras publicadas en el artículo para un benchmark concreto, no una medición de su carga de trabajo. La diferencia entre ambas cifras representa aproximadamente lo que cuesta hoy una garantía real.

Hasta que un diseño de este tipo esté disponible en las herramientas que usa a diario, dé por hecho que el agente quedará comprometido en algún momento y haga que ese incidente sea poco relevante. Ese es el fundamento de usar una máquina desechable, credenciales con permisos limitados, tráfico saliente controlado y el hábito de revisar el diff.

FAQ

¿Puedo detener la inyección de prompts indicando al agente que ignore las instrucciones de los archivos?

No. Esa frase está en la misma ventana de contexto que el ataque y compite con el texto del atacante en igualdad de condiciones. La documentación de Claude Code establece claramente la diferencia: las instrucciones del prompt o CLAUDE.md determinan lo que el agente intenta hacer, pero no cambian lo que la herramienta permite. Trate un archivo de instrucciones como una declaración de intención y coloque todo aquello de lo que dependa en reglas de permisos, un hook PreToolUse o una regla de firewall.

¿La inyección de prompts supone un riesgo real si el agente sólo accede a mi propio repositorio?

Sí, porque el repositorio contiene mucho texto que usted no escribió. Los archivos README de las dependencias, las URL de los lockfiles, los dispositivos de prueba, el código incluido de terceros y la salida de npm install se incorporan durante una tarea normal. Todo lo que se obtiene de un sistema de seguimiento de incidencias o de un sitio de documentación llega de la misma forma. El riesgo aumenta cuanto más contenido lee el agente, y un agente útil lee mucho.

¿Ejecutar el agente en un contenedor resuelve el problema?

Limita los daños, pero sólo si también retira las credenciales. Un contenedor con el SSH agent reenviado, credenciales de servicios cloud en el entorno y acceso de red sin restricciones entrega a un atacante casi todo lo que tendría el host. Lo que realmente aporta el contenedor es un sistema de archivos que puede eliminar y un entorno limpio donde aplicar reglas de salida. Combínelo con un token limitado a un único repositorio.

¿Qué cambio único reduce más el riesgo?

Retire las credenciales de larga duración del entorno que heredan los comandos del agente y, después, aplique a esa máquina una política de salida con denegación predeterminada. Juntos, estos cambios rompen la tercera condición de la tríada letal: el texto aún puede secuestrar al agente, pero los datos a los que accede no tienen ningún destino útil. Los prompts de aprobación y la revisión de diferencias también ayudan, pero dependen de que una persona se mantenga alerta durante una ejecución larga. Por eso ocupan un nivel inferior a esos dos cambios.

¿Te resultó útil este artículo?