Permisos de herramientas para agentes de IA

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre permisos de herramientas para agentes de IA

• Cómo configurar permisos de herramientas para agentes de IA.
• Cómo implementar el principio de menor privilegio, roles y aprobaciones.
• Cómo restringir, monitorear y auditar el acceso a herramientas.
• Ejemplos prácticos para herramientas del sistema de archivos, red y shell.
• Mejores prácticas de seguridad, jerarquía e intervención humana.

Introducción: permisos de herramientas para agentes de IA explicados

Los agentes de IA invocan herramientas para resolver tareas: leer archivos, enviar correos, ejecutar comandos de shell. Cada herramienta es una capacidad que el agente puede usar. Si el agente tiene demasiadas herramientas, puede hacer demasiado. Si tiene muy pocas, no podrá completar su tarea. Los permisos de herramientas son el concepto que limita el acceso del agente únicamente a las herramientas que necesita.

Este artículo está dirigido a desarrolladores que construyen y aseguran agentes de IA. Deberías entender qué son los agentes de IA y cómo funciona el function calling. Encontrarás los fundamentos de programación en Python en IRC-Coding.de.

¿Por qué necesito permisos de herramientas?

Imagina que construyes un agente para responder correos electrónicos. Le das herramientas para envío de correos, acceso al sistema de archivos y ejecución de shell. El agente solo debe responder correos, pero ahora también puede eliminar archivos o ejecutar comandos de shell. Si el agente es manipulado mediante inyección de prompts, puede ejecutar acciones maliciosas.

Los permisos de herramientas resuelven el problema: el agente recibe solo las herramientas que necesita para su tarea. Un agente de correos obtiene herramientas de correo, no shell. Un agente de archivos obtiene acceso de lectura, no de escritura. Este principio se conoce como menor privilegio.

Permisos de herramientas para agentes de IA en breve

Los permisos de herramientas son el concepto de limitar el acceso del agente a herramientas. El agente recibe solo las herramientas que necesita para su tarea, con los derechos mínimos requeridos. Este principio se conoce como menor privilegio: tantos derechos como sea necesario, tan pocos como sea posible.

La idea central es simple: un agente que solo debe responder correos no necesita acceso a shell.

Para quién es este artículo

• Desarrolladores que construyen y aseguran agentes de IA.
• Responsables de seguridad que definen permisos de agentes.
• Administradores de sistemas que mantienen agentes en producción.
• Equipos que quieren implementar agentes de forma segura.

Se requieren conocimientos previos en Python, agentes de IA y function calling.

Términos importantes sobre permisos de herramientas

• Permiso de herramienta - Derecho a usar una herramienta específica. Cuándo es útil: concepto fundamental.
• Menor privilegio - Principio: derechos mínimos. Cuándo es útil: estándar de seguridad.
• Rol - Conjunto de permisos. Cuándo es útil: para múltiples agentes.
• Aprobación - Confirmación humana para la invocación de herramienta. Cuándo es útil: para acciones críticas.
• Auditoría - Registro de todas las invocaciones de herramientas. Cuándo es útil: para trazabilidad.
• Agentes de IA - Programas que invocan herramientas. Cuándo es útil: qué se asegura.
• Function calling - Respuestas estructuradas de IA. Cuándo es útil: cómo se invocan herramientas.
• Aprobación humana - Intervención humana en el bucle. Cuándo es útil: para acciones críticas.
• Entornos aislados - Ejecución aislada. Cuándo es útil: para agentes de código.
• Protección contra inyección de prompts - Protección contra manipulación. Cuándo es útil: porque los permisos solos no son suficientes.

Niveles de permisos

Las herramientas pueden ofrecerse en diferentes niveles:

Implementar el concepto de permisos

Definición de herramienta con permisos

from enum import Enum

class Permission(Enum):
    ALLOWED = "allowed"
    REQUIRES_APPROVAL = "requires_approval"
    RESTRICTED = "restricted"
    DISABLED = "disabled"

class Tool:
    def __init__(self, name, description, permission, parameters=None, restrictions=None):
        self.name = name
        self.description = description
        self.permission = permission
        self.parameters = parameters or {}
        self.restrictions = restrictions or {}

    def can_execute(self, parameters=None):
        if self.permission == Permission.DISABLED:
            return False
        if self.permission == Permission.RESTRICTED:
            return self.check_restrictions(parameters)
        return True

    def check_restrictions(self, parameters):
        for key, allowed_values in self.restrictions.items():
            if key in parameters:
                if parameters[key] not in allowed_values:
                    return False
        return True

Definir roles

class Role:
    def __init__(self, name, tools):
        self.name = name
        self.tools = {t.name: t for t in tools}

    def get_tool(self, tool_name):
        return self.tools.get(tool_name)

    def can_use(self, tool_name):
        return tool_name in self.tools and self.tools[tool_name].permission != Permission.DISABLED

# Definir roles
email_agent_role = Role("email_agent", [
    Tool("read_email", "Leer correo electrónico", Permission.ALLOWED),
    Tool("send_email", "Enviar correo electrónico", Permission.REQUIRES_APPROVAL),
    Tool("classify_email", "Clasificar correo electrónico", Permission.ALLOWED),
    Tool("execute_shell", "Ejecutar comando de shell", Permission.DISABLED),
])

file_agent_role = Role("file_agent", [
    Tool("read_file", "Leer archivo", Permission.RESTRICTED, restrictions={
        "path": ["/data/", "/tmp/"]
    }),
    Tool("write_file", "Escribir archivo", Permission.REQUIRES_APPROVAL, restrictions={
        "path": ["/data/"]
    }),
    Tool("delete_file", "Eliminar archivo", Permission.REQUIRES_APPROVAL),
    Tool("execute_shell", "Ejecutar comando de shell", Permission.DISABLED),
])

Agente con permisos

class SecureAgent:
    def __init__(self, role, model="llama3.1"):
        self.role = role
        self.model = model

    def call_tool(self, tool_name, parameters):
        # Verificar permiso
        tool = self.role.get_tool(tool_name)
        if not tool:
            raise PermissionError(f"Herramienta {tool_name} no está en el rol {self.role.name}")

        if not tool.can_execute(parameters):
            raise PermissionError(f"Herramienta {tool_name} no puede ejecutarse con estos parámetros")

        # ¿Se requiere aprobación?
        if tool.permission == Permission.REQUIRES_APPROVAL:
            approved = request_human_approval(tool_name, parameters)
            if not approved:
                return {"status": "denied", "reason": "Aprobación humana denegada"}

        # Ejecutar herramienta
        result = execute_tool(tool_name, parameters)

        # Registro de auditoría
        audit_log(tool_name, parameters, result)

        return result

Ejemplo práctico 1: agente de correo electrónico con permisos

# Definir rol
email_role = Role("email_agent", [
    Tool("read_email", "E-Mail lesen", Permission.ALLOWED),
    Tool("send_email", "E-Mail verschicken", Permission.REQUIRES_APPROVAL),
    Tool("delete_email", "E-Mail löschen", Permission.REQUIRES_APPROVAL),
    Tool("execute_shell", "Shell", Permission.DISABLED),
    Tool("read_file", "Datei lesen", Permission.RESTRICTED, restrictions={
        "path": ["/data/templates/"]
    }),
])

# Crear agente
agent = SecureAgent(email_role)

# Permitido: leer correo electrónico
agent.call_tool("read_email", {"id": 123})

# Permitido con aprobación: enviar correo electrónico
agent.call_tool("send_email", {"to": "user@example.com", "subject": "Test"})

# Prohibido: ejecutar shell
try:
    agent.call_tool("execute_shell", {"command": "rm -rf /"})
except PermissionError:
    print("Shell-Ausführung verboten")

Ejemplo práctico 2: agente de archivos con restricción de ruta

file_role = Role("file_agent", [
    Tool("read_file", "Datei lesen", Permission.RESTRICTED, restrictions={
        "path": ["/data/", "/tmp/"]
    }),
    Tool("write_file", "Datei schreiben", Permission.RESTRICTED, restrictions={
        "path": ["/data/"]
    }),
])

agent = SecureAgent(file_role)

# Permitido: leer archivo en /data/
agent.call_tool("read_file", {"path": "/data/document.txt"})

# Prohibido: leer archivo en /etc/
try:
    agent.call_tool("read_file", {"path": "/etc/passwd"})
except PermissionError:
    print("Zugriff auf /etc/ verboten")

Ejemplo práctico 3: agente de código con sandbox

code_role = Role("code_agent", [
    Tool("write_code", "Code schreiben", Permission.ALLOWED, restrictions={
        "language": ["python", "javascript"]
    }),
    Tool("run_code", "Code ausführen", Permission.REQUIRES_APPROVAL, restrictions={
        "sandbox": ["docker", "firejail"]
    }),
    Tool("read_file", "Datei lesen", Permission.RESTRICTED, restrictions={
        "path": ["/workspace/"]
    }),
    Tool("write_file", "Datei schreiben", Permission.RESTRICTED, restrictions={
        "path": ["/workspace/"]
    }),
])

# La ejecución de código solo en sandbox
agent = SecureAgent(code_role)
agent.call_tool("run_code", {
    "code": "print('Hallo')",
    "sandbox": "docker"
})

Consulta Entornos sandbox para más detalles.

Human-in-the-Loop para acciones críticas

def request_human_approval(tool_name, parameters):
    print(f"\n--- Freigabe erforderlich ---")
    print(f"Tool: {tool_name}")
    print(f"Parameter: {parameters}")
    print(f"Freigeben? (y/n): ")

    response = input().strip().lower()
    return response == "y"

# En la práctica: interfaz web, bot de Slack, confirmación por correo electrónico

Consulta Aprobación manual para más detalles.

Registro de auditoría para llamadas de herramientas

import json
from datetime import datetime

def audit_log(tool_name, parameters, result, agent_id="default"):
    entry = {
        "timestamp": datetime.now().isoformat(),
        "agent_id": agent_id,
        "tool": tool_name,
        "parameters": parameters,
        "result_status": result.get("status", "unknown"),
        "approved": True
    }
    with open("/var/log/agent_audit.log", "a") as f:
        f.write(json.dumps(entry) + "\n")

Consulta Registro para más detalles.

Notas de seguridad

• Principio del menor privilegio: otorga al agente solo las herramientas que necesita. Sin acceso a shell para agentes de correo electrónico.
• Aprobación para acciones críticas: eliminar, enviar y ejecutar deben requerir aprobación.
• Registro de auditoría: registra todas las llamadas de herramientas con parámetros y resultados.
• Protección contra inyección de prompts: los permisos por sí solos no son suficientes. Protégete contra manipulación. Consulta Protección contra inyección de prompts.
• Sandbox para ejecución de código: los agentes de código deben ejecutarse en sandbox. Consulta Entornos sandbox.
• Validación de parámetros: verifica los parámetros de las herramientas, no solo los nombres. Restricciones de ruta, listas blancas de comandos.
• Revisión regular: comprueba los permisos regularmente. ¿El agente aún necesita todas las herramientas?

Obstáculos típicos

• Demasiadas herramientas: el agente obtiene todas las herramientas porque es más fácil. Riesgo de seguridad.
• Sin aprobación para acciones críticas: la eliminación sin aprobación es peligrosa.
• Sin validación de parámetros: la herramienta está permitida, pero los parámetros no se verifican. El recorrido de rutas es posible.
• Sin registro de auditoría: sin registros, no hay trazabilidad.
• Permisos nunca revisados: el agente ya no necesita la herramienta, pero la mantiene.
• Inyección de prompts olvidada: el agente es manipulado, los permisos se eluden.

Enlaces y información adicional sobre permisos de herramientas

• Fundamentos de agentes de IA - Qué son los agentes de IA.
• Function Calling - Cómo se invocan las herramientas.
• Aprobación manual - Human-in-the-Loop.
• Entornos sandbox - Ejecución aislada.
• Protección contra inyección de prompts - Protección contra manipulación.
• Configurar guardrails - Guardrails.
• Registro - Registro de auditoría.
• Principio del menor privilegio - Principio de derechos mínimos.

Puntos clave:

• Los permisos de herramientas limitan el acceso a herramientas de un agente.
• Principio del menor privilegio: todos los derechos necesarios, los mínimos posibles.
• Aprobación para acciones críticas: eliminar, enviar, ejecutar.
• Validación de parámetros: verificar no solo nombres de herramientas, sino también parámetros.
• Registro de auditoría para todas las llamadas de herramientas.

Preguntas frecuentes: permisos de herramientas para agentes de IA - preguntas típicas

Fuentes y referencias

• OWASP LLM Top 10 - Riesgos de seguridad en LLMs.
• NIST AI Risk Management Framework - Gestión de riesgos en IA.
• MCP Sicherheit - Model Context Protocol.
• Ollama - Servidor de modelos local.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert