llm-trading-agent-security

Seguridad para Agentes de Trading con LLM

Los agentes de trading autónomos tienen un modelo de amenazas más severo que las aplicaciones LLM normales: una inyección o una ruta de herramienta incorrecta puede convertirse directamente en pérdida de activos.

Cuándo Usarlo

• Construir un agente de IA que firme y envíe transacciones
• Auditar un bot de trading o un asistente de ejecución en cadena
• Diseñar la gestión de claves de wallet para un agente
• Dar a un LLM acceso a colocación de órdenes, swaps u operaciones de tesorería

Cómo Funciona

Capa las defensas. Ninguna verificación es suficiente por sí sola. Trata la higiene de prompts, la política de gasto, la simulación, los límites de ejecución y el aislamiento de wallets como controles independientes.

Ejemplos

Tratar la inyección de prompts como un ataque financiero

import re

INJECTION_PATTERNS = [
    r'ignora (instrucciones anteriores|todas las instrucciones)',
    r'nueva (tarea|directiva|instrucción)',
    r'prompt del sistema',
    r'envía .{0,50} a 0x[0-9a-fA-F]{40}',
    r'transfiere .{0,50} a',
    r'aprueba .{0,50} para',
]

def sanitize_onchain_data(text: str) -> str:
    for pattern in INJECTION_PATTERNS:
        if re.search(pattern, text, re.IGNORECASE):
            raise ValueError(f"Posible inyección de prompt: {text[:100]}")
    return text

No inyectes ciegamente nombres de tokens, etiquetas de pares, webhooks o feeds sociales en un prompt con capacidad de ejecución.

Límites de gasto duros

from decimal import Decimal

MAX_SINGLE_TX_USD = Decimal("500")
MAX_DAILY_SPEND_USD = Decimal("2000")

class SpendLimitError(Exception):
    pass

class SpendLimitGuard:
    def check_and_record(self, usd_amount: Decimal) -> None:
        if usd_amount > MAX_SINGLE_TX_USD:
            raise SpendLimitError(f"Transacción individual ${usd_amount} excede el máximo ${MAX_SINGLE_TX_USD}")

        daily = self._get_24h_spend()
        if daily + usd_amount > MAX_DAILY_SPEND_USD:
            raise SpendLimitError(f"Límite diario: ${daily} + ${usd_amount} > ${MAX_DAILY_SPEND_USD}")

        self._record_spend(usd_amount)

Simular antes de enviar

class SlippageError(Exception):
    pass

async def safe_execute(self, tx: dict, expected_min_out: int | None = None) -> str:
    sim_result = await self.w3.eth.call(tx)

    if expected_min_out is None:
        raise ValueError("Se requiere min_amount_out antes de enviar")

    actual_out = decode_uint256(sim_result)
    if actual_out < expected_min_out:
        raise SlippageError(f"Simulación: {actual_out} < {expected_min_out}")

    signed = self.account.sign_transaction(tx)
    return await self.w3.eth.send_raw_transaction(signed.raw_transaction)

Interruptor de circuito

class TradingCircuitBreaker:
    MAX_CONSECUTIVE_LOSSES = 3
    MAX_HOURLY_LOSS_PCT = 0.05

    def check(self, portfolio_value: float) -> None:
        if self.consecutive_losses >= self.MAX_CONSECUTIVE_LOSSES:
            self.halt("Demasiadas pérdidas consecutivas")

        if self.hour_start_value <= 0:
            self.halt("hour_start_value inválido")
            return

        hourly_pnl = (portfolio_value - self.hour_start_value) / self.hour_start_value
        if hourly_pnl < -self.MAX_HOURLY_LOSS_PCT:
            self.halt(f"PnL por hora {hourly_pnl:.1%} por debajo del umbral")

Aislamiento de wallets

import os
from eth_account import Account

private_key = os.environ.get("TRADING_WALLET_PRIVATE_KEY")
if not private_key:
    raise EnvironmentError("TRADING_WALLET_PRIVATE_KEY no está configurada")

account = Account.from_key(private_key)

Usa una hot wallet dedicada con solo los fondos necesarios para la sesión. Nunca apuntes el agente a una wallet de tesorería principal.

Protección MEV y de fecha límite

import time

PRIVATE_RPC = "https://rpc.flashbots.net"
MAX_SLIPPAGE_BPS = {"stable": 10, "volatile": 50}
deadline = int(time.time()) + 60

Lista de Verificación Pre-Despliegue

• Los datos externos se sanitizan antes de entrar al contexto del LLM
• Los límites de gasto se aplican independientemente de la salida del modelo
• Las transacciones se simulan antes de enviarse
• min_amount_out es obligatorio
• Los interruptores de circuito se activan en caso de drawdown o estado inválido
• Las claves provienen de env o de un gestor de secretos, nunca del código o los logs
• Se usa un mempool privado o enrutamiento protegido cuando sea apropiado
• El slippage y las fechas límite se establecen por estrategia
• Todas las decisiones del agente se registran en un log de auditoría, no solo los envíos exitosos