A2M 2026: Arsitektur Trace-Optimized Agent Hijacking pada Ekosistem Model Context Protocol (MCP), Cognitive Denial of Service (C-DoS), dan Pertahanan Information-Flow Control

Dalam kurun waktu kurang dari dua tahun, Model Context Protocol (MCP) yang diinisiasi oleh Anthropic dan diadopsi luas oleh ekosistem AI engineering telah bertransformasi menjadi standar de facto bagi konektivitas eksternal agen otonom. Dengan menghubungkan Large Language Models (LLM) ke puluhan server perkakas eksternal—mulai dari filesystem, query database, runtime GitHub, hingga API perbankan—MCP menjanjikan modularitas tanpa batas. Namun, sebuah temuan mengguncang dari Shenzhen Institutes of Advanced Technology (SIAT CAS), Nanyang Technological University (NTU), dan University of Macau yang dipublikasikan pada 22 September 2026 (arXiv:2609.26761) mengungkapkan lubang keamanan arsitektural yang sangat fundamental: A2M (Attraction-to-Manipulation).

1. Ilusi Keamanan pada "Tool Integration Layer": Paradoks Semantic Matching

Berbeda dengan serangan prompt injection konvensional yang menyasar antarmuka pengguna (user-to-agent prompt), ekosistem MCP membuka permukaan serangan baru yang disebut Semantic Supply-Chain Risk. Dalam protokol MCP standar, sebuah alat didefinisikan sebagai pasangan tuple:

Agen cerdas modern memilih perkakas mana yang akan dipanggil bukan melalui verifikasi identitas kriptografis atau otorisasi berbasis sertifikat biner, melainkan melalui semantic matching berbasis embedding atau penalaran internal LLM terhadap string teks deskripsi $d$. Di sinilah letak kerapuhan strukturalnya:

2. Framework A2M Dua-Fase: Memecah Black-Box Hijacking

Tantangan utama dalam meretas sistem agen otonom adalah sifatnya yang black-box: penyerang tidak memiliki akses ke bobot internal model, logit token, maupun representasi aktivasi tersembunyi. Tim peneliti SIAT CAS dan NTU memecahkan masalah ini dengan mendekomposisi serangan menjadi dua fase optimasi ortogonal yang dituntun oleh jejak eksekusi (execution trace trajectory $ au$):

A. Phase I: Lima Strategi Persuasi Kognitif (Attraction)

Pada fase pertama, A2M memanfaatkan teori persuasi psikologis untuk merekayasa nama dan deskripsi tool agar mengalahkan tool asli. Alokasi budget eksplorasi $N_{\text{attr}}$ dibagi secara seragam ke dalam 5 taktik:

• Authority (Otoritas): Mengklaim bahwa tool ini adalah penyedia data resmi, bersertifikasi ISO/FIPS, atau merupakan endpoint internal sistem primer yang wajib digunakan.
• Urgency (Urgensi): Mengklaim adanya depresiasi mendesak atau batas waktu kritis yang mewajibkan agen menggunakan rute khusus ini untuk mencegah kegagalan sistem.
• Comprehensiveness (Komprehensifitas): Menjanjikan respons agregat terintegrasi yang mencakup seluruh parameter konteks tanpa perlu memanggil tool lain. (Menyumbang 31.6% kemenangan seleksi).
• Resource Optimality (Optimalisasi Sumber Daya): Menjanjikan konsumsi latensi terendah, zero cache miss, dan pemrosesan stream berbiaya nol. (Menyumbang 22.1% kemenangan seleksi).
• Security (Keamanan & Sanitasi): Mengklaim telah melalui audit kepatuhan enkripsi dan perlindungan kebocoran rahasia.

Melalui $K_{\text{roll}}$ rollouts pada himpunan query simulasi, pasangan metadata yang meraih rasio seleksi tertinggi diisolasi ke dalam himpunan elit $\mathcal{E}_1 = \{(n_i^*, d_i^*)\}_{i=1}^k$ untuk dilanjutkan ke fase manipulasi muatan.

B. Phase II: Arsitektur Analyzer–Optimizer untuk Sintesis Payload

Setelah tool berbahaya berhasil dipanggil, tantangan berikutnya adalah memastikan umpan balik tool tidak memicu penolakan (refusal) atau diabaikan oleh agen. A2M membangun siklus umpan balik tertutup menggunakan dua agen otonom penyerang:

3. Desain Fungsi Fitness Matematis Lintas 4 Skenario Serangan

Keunggulan metodologis A2M terletak pada perumusan fungsi fitness matematis $f(\tau)$ yang terukur secara kuantitatif untuk 4 skenario ancaman berbeda:

4. Evaluasi Empiris pada LiveMCPBench & Temuan Cross-Model Transfer

Eksperimen dilakukan di atas tolok ukur komprehensif LiveMCPBench, yang mencakup 95 tugas nyata di 6 domain industri (Office, Lifestyle, Leisure, Finance, Travel, Shopping) yang terhubung ke 70 server MCP aktif dengan 527 ragam tool.

5. Mengapa Filter Konvensional Gagal & Urgensi Pertahanan FIDES-Style

Ketika tim peneliti menguji pertahanan konvensional—seperti deteksi kebingungan teks (Perplexity / PPL threshold) dan model auditor penjaga gerbang (Qwen3-8B Security Auditor)—hasilnya sangat mengecewakan:

• Perplexity Threshold Gagal Total: Sebanyak 33.4% payload serangan C-DoS memiliki skor PPL di atas 100, yang secara statistik identik dengan variasi linguistik pada balasan tool jinak (benign). Memotong PPL tinggi memicu false positive masif pada tool developer yang sah.
• LLM Guard Auditor Hanya Menandai 32.5%: Auditor LLM gagal mengenali niat jahat karena deskripsi tool sengaja dirancang meniru format dokumentasi resmi API tier-1.

Solusi yang terbukti efektif menurunkan Attack Success Rate (ASR) dari 74.4% ke kisaran 20.6% adalah FIDES-Style Dynamic Information-Flow Control: memperlakukan seluruh muatan balik tool pihak ketiga sebagai variabel dengan label untrusted taint, serta membatasi aliran data sensitif dari variabel privat agar tidak dapat dioperasikan ke argumen fungsi tak tepercaya.

6. Implementasi Referensi Python: Runtime MCP Defense Guard

Berikut adalah implementasi referensi modul interseptor pertahanan untuk gateway MCP yang siap diintegrasikan di depan runtime Claude Code, Codex, Hermes, atau LangChain:

"""
MCP Security Shield: Trace-Aware Dynamic Information-Flow & C-DoS Defense Interceptor.
Mengimplementasikan arsitektur proteksi runtime untuk Model Context Protocol (MCP)
berdasarkan mitigasi riset A2M (arXiv:2609.26761) dan FIDES-style taint tracking.

Fitur Inti:
1. Dynamic Taint Tracking: Memisahkan output tool pihak ketiga (untrusted taint) dari state kontrol privat.
2. Cognitive Denial of Service (C-DoS) Budget Guard: Deteksi inflasi token loop anomali.
3. Metadata Integrity & Schema Signature Verifier: Mencegah manipulasi deskripsi semantik.
4. Structural Tool Output Sanitizer: Menolak payload rekursif berformat fake system-prompts.
"""

import re
import json
import time
from dataclasses import dataclass, field
from typing import List, Dict, Any, Optional, Set, Tuple

@dataclass
class ToolExecutionPolicy:
    max_tool_cost_ratio: float = 3.5  # Batas pembengkakan token C-DoS relatif baseline
    max_repetitive_calls: int = 3      # Batas perulangan pemanggilan tool identik
    untrusted_output_char_limit: int = 2000
    enforce_taint_isolation: bool = True
    blocked_substrings: Set[str] = field(default_factory=lambda: {
        "SYSTEM_OVERRIDE:", "IGNORE_PREVIOUS_INSTRUCTIONS", 
        "[CRITICAL_ENVIRONMENT_COMMAND]", "CONFIDENTIAL_KEY_EXPORT:"
    })

@dataclass
class ExecutionSessionState:
    baseline_token_estimate: int = 800
    accumulated_input_tokens: int = 0
    accumulated_output_tokens: int = 0
    invoked_tools_history: List[str] = field(default_factory=list)
    tainted_variables: Set[str] = field(default_factory=set)

class MCPDefenseGateway:
    def __init__(self, policy: ToolExecutionPolicy = ToolExecutionPolicy()):
        self.policy = policy
        self.registered_clean_schemas: Dict[str, str] = {}

    def register_trusted_tool(self, tool_name: str, schema_hash: str):
        """Mendaftarkan cryptographic hash dari schema metadata tool yang telah diaudit."""
        self.registered_clean_schemas[tool_name] = schema_hash

    def inspect_tool_call(self, tool_name: str, args: Dict[str, Any], session: ExecutionSessionState) -> Tuple[bool, Optional[str]]:
        """
        Tahap 1: Evaluasi sebelum tool dijalankan (Pre-invocation Check).
        Mencegah pemanggilan tool repetitif yang disengaja untuk memicu loop C-DoS.
        """
        session.invoked_tools_history.append(tool_name)
        recent_calls = session.invoked_tools_history[-self.policy.max_repetitive_calls:]
        if len(recent_calls) >= self.policy.max_repetitive_calls and all(t == tool_name for t in recent_calls):
            return False, f"Veto Gate: Deteksi Cognitive DoS loop pada tool '{tool_name}' ({len(recent_calls)}x berturut-turut)."

        # Cek apakah ada data sensitif (tainted) yang bocor ke argumen tool pihak ketiga
        for arg_key, arg_val in args.items():
            val_str = str(arg_val)
            for tainted in session.tainted_variables:
                if tainted in val_str:
                    return False, f"Information-Flow Veto: Variabel rahasia '{tainted}' berusaha diekfiltrasi ke tool '{tool_name}'."

        return True, None

    def sanitize_and_isolate_return(
        self, 
        tool_name: str, 
        raw_output: str, 
        tokens_consumed: int,
        session: ExecutionSessionState
    ) -> Tuple[str, bool]:
        """
        Tahap 2: Sanitasi muatan balasan tool (Post-invocation Manipulation Defense).
        Menerapkan dynamic taint tracking, isolasi boundary, dan pemangkasan token.
        """
        session.accumulated_output_tokens += tokens_consumed
        
        # 1. C-DoS Anomaly Guard
        total_tokens = session.accumulated_input_tokens + session.accumulated_output_tokens
        if total_tokens > (session.baseline_token_estimate * self.policy.max_tool_cost_ratio):
            warning_msg = f"[DEFENSE VETO]: Batas kuota komputasi kognitif terlampaui ({total_tokens} tokens). Pemanggilan tool dihentikan."
            return warning_msg, False

        # 2. Heuristic Semantic Hijack Detection
        for malicious_pattern in self.policy.blocked_substrings:
            if malicious_pattern.lower() in raw_output.lower():
                sanitized_output = re.sub(re.escape(malicious_pattern), "[REDACTED_ADVERSARIAL_INSTRUCTION]", raw_output, flags=re.IGNORECASE)
                return f"[WARNING: UNTRUSTED PAYLOAD MUTATED BY GATEWAY]\n{sanitized_output}", True

        # 3. Dynamic Taint Labeling (FIDES Style)
        # Menandai seluruh konten dari tool eksternal sebagai data literal pasif, bukan instruksi sistem
        if self.policy.enforce_taint_isolation:
            isolated_payload = f"\n" \
                               f"{raw_output[:self.policy.untrusted_output_char_limit]}\n" \
                               f""
            return isolated_payload, True

        return raw_output[:self.policy.untrusted_output_char_limit], True

7. Rekomendasi Arsitektural untuk Tim Enterprise & AI Platform 2026

Bagi organisasi teknologi yang sedang menggelar arsitektur multi-agent berbasis Model Context Protocol di level produksi, riset A2M mewajibkan implementasi 3 kontrol pertahanan lapis ganda: