LLM Trading Agent Sicherheit

Was macht LLM Trading Agent Sicherheit?

Autonome Handelsagenten haben ein strengeres Bedrohungsmodell als normale LLM-Apps: Eine Injection oder ein schlechter Tool-Pfad kann direkt zu Vermögensverlusten führen.

Wann verwenden

• Bau eines KI-Agenten, der Transaktionen signiert und sendet
• Audit eines Trading-Bots oder On-Chain-Ausführungsassistenten
• Entwurf der Wallet-Schlüsselverwaltung für einen Agenten
• Gewährung von LLM-Zugriff auf Orderaufgabe, Swaps oder Treasury-Operationen

Funktionsweise

Schichte die Verteidigung. Keine einzelne Prüfung ist ausreichend. Behandle Prompt-Hygiene, Ausgabenpolitik, Simulation, Ausführungslimits und Wallet-Isolation als unabhängige Kontrollen.

Beispiele

Prompt-Injection als finanziellen Angriff behandeln

import re

INJECTION_PATTERNS = [
    r'ignore (previous|all) instructions',
    r'new (task|directive|instruction)',
    r'system prompt',
    r'send .{0,50} to 0x[0-9a-fA-F]{40}',
    r'transfer .{0,50} to',
    r'approve .{0,50} for',
]

def sanitize_onchain_data(text: str) -> str:
    for pattern in INJECTION_PATTERNS:
        if re.search(pattern, text, re.IGNORECASE):
            raise ValueError(f"Potentielle Prompt-Injection: {text[:100]}")
    return text

Token-Namen, Paar-Labels, Webhooks oder soziale Feeds nicht blind in einen ausführungsfähigen Prompt einfügen.

Harte Ausgabenlimits

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"Einzel-Tx ${usd_amount} überschreitet Maximum ${MAX_SINGLE_TX_USD}")

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

        self._record_spend(usd_amount)

Vor dem Senden simulieren

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("min_amount_out ist vor dem Senden erforderlich")

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

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

Schutzschalter

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("Zu viele aufeinanderfolgende Verluste")

        if self.hour_start_value <= 0:
            self.halt("Ungültiger hour_start_value")
            return

        hourly_pnl = (portfolio_value - self.hour_start_value) / self.hour_start_value
        if hourly_pnl < -self.MAX_HOURLY_LOSS_PCT:
            self.halt(f"Stündlicher PnL {hourly_pnl:.1%} unter Schwellwert")

Wallet-Isolation

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 nicht gesetzt")

account = Account.from_key(private_key)

Verwenden Sie ein dediziertes Hot-Wallet mit nur den erforderlichen Sitzungsgeldern. Richten Sie den Agenten niemals auf ein primäres Treasury-Wallet.

MEV- und Fristenschutz

import time

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

Pre-Deploy-Checkliste

• Externe Daten werden bereinigt, bevor sie in den LLM-Kontext gelangen
• Ausgabenlimits werden unabhängig von der Modellausgabe durchgesetzt
• Transaktionen werden vor dem Senden simuliert
• min_amount_out ist obligatorisch
• Schutzschalter stoppen bei Wertverlust oder ungültigem Zustand
• Schlüssel stammen aus Umgebungsvariablen oder einem Secret Manager, niemals aus Code oder Logs
• Private Mempool oder geschütztes Routing wird verwendet, wenn angemessen
• Slippage und Fristen werden pro Strategie festgelegt
• Alle Agentenentscheidungen werden geprüft protokolliert, nicht nur erfolgreiche Sendungen