Endogenous Authorization Laundering: Arsitektur Provenance-Grounded Agent Memory & Bounded Event Sourcing untuk Keamanan Autonomous Multi-Agent 2026

Dalam lanskap rekayasa kecerdasan buatan 2026, adopsi long-running LLM agents dan sistem multi-agent otonom bertumpu pada satu fondasi vital: persistent memory. Memori jangka panjang memungkinkan agen mempertahankan konteks lintas sesi, merekam preferensi pengguna, aturan kepatuhan organisasi, dan hak akses (authorization privileges). Namun, riset keamanan mutakhir mengungkap kerentanan fatal yang beroperasi tanpa perlu serangan siber eksternal atau manipulasi prompt: Endogenous Authorization Laundering (EAL).

1. Anatomi Endogenous Authorization Laundering: Mengapa Memori AI Menjadi Vektor Serangan Internal?

Selama ini, ancaman keamanan pada LLM berfokus pada exogenous attacks seperti Direct Prompt Injection, Jailbreaking, dan Data Poisoning. Namun, EAL adalah kegagalan endogen (internal) murni yang muncul dari dinamika pembaruan memori rekursif.

Proses terjadinya Authorization Laundering mengikuti rantai degradasi semantik berikut:

Ketika batasan izin (conditional constraints, temporal leases, scope boundaries) terlepas selama proses perangkuman teks memori (lossy summarization), provenance (asal-usul) otorisasi tersebut terhapus. Bagi model eksekutor di downstream, entri memori internal dianggap sebagai kebijakan resmi (ground truth authority).

2. Evaluasi Empiris EAL-Bench: Benchmark Keamanan Lintas Domain

Benchmark EAL-Bench menguji 5 model frontier sebagai memory writers dan 2 model sebagai executors pada 3 domain berisiko tinggi: Procurement (Pengadaan Finansial), Cybersecurity Operations, dan Finance Ledger Management.

Data empiris mengungkap fenomena krusial: pada arsitektur berbasis *free-text memory* tradisional, ketika otorisasi palsu terlanjur tertulis ke dalam memori, agen eksekutor hampir selalu (98.6%) mempercayai catatan tersebut dan melakukan tindakan berbahaya (seperti transfer dana tak sah atau pembukaan firewall).

3. Arsitektur Pertahanan: Provenance Grounding & Bounded Event Sourcing

Untuk menghentikan Endogenous Authorization Laundering pada sistem produksi enterprise, tim arsitektur NEWSAINT mengadopsi pola pertahanan lapis ganda:

A. Provenance-Grounded Claims

Setiap klaim hak akses yang disimpan di memori agen wajib memiliki tautan kriptografis (cryptographic backlink) ke raw event asli yang ditandatangani secara digital. Agen memori dilarang memanipulasi atau memperluas cakupan izin di luar metadata yang tertera pada event induk.

B. Bounded Event Sourcing State Projections

Menggantikan mutasi memori in-place dengan model Append-Only Event Store. Kondisi hak akses saat ini dihitung secara deterministik (deterministic projection) dari urutan event yang valid, lengkap dengan temporal lease (masa berlaku terbatas) dan tombstone revocation events.

// Provenance-Grounded Agent Memory Engine & Bounded Event Sourcing Runtime
// Mitigasi Endogenous Authorization Laundering (EAL) pada Sistem Multi-Agent 2026
import { createHash, createHmac } from 'crypto';

export type ActionScope = 'read' | 'write' | 'execute' | 'admin';

export interface RawExecutionEvent {
  eventId: string;
  timestamp: number;
  actorId: string;
  sourceType: 'user_explicit_prompt' | 'system_policy' | 'delegated_agent';
  scope: ActionScope;
  resourceTarget: string;
  conditions: {
    ttlSeconds?: number;
    requiresApprovalAboveUsd?: number;
    sessionBoundOnly?: boolean;
  };
  rawInstructionText: string;
  signature: string;
}

export interface GroundedMemoryClaim {
  claimId: string;
  sourceEventId: string;
  sourceEventHash: string;
  scope: ActionScope;
  resourceTarget: string;
  validUntil: number;
  isRevoked: boolean;
  provenanceProof: string;
}

export class ProvenanceGroundedMemoryStore {
  private eventLog: RawExecutionEvent[] = [];
  private memoryClaims: Map<string, GroundedMemoryClaim> = new Map();
  private secretKey: string;

  constructor(secretKey: string = 'newsaint-sec-k-2026') {
    this.secretKey = secretKey;
  }

  // 1. Append-Only Immutable Event Sourcing Log
  public recordAuthorizationEvent(event: Omit<RawExecutionEvent, 'eventId' | 'signature'>): RawExecutionEvent {
    const eventId = `evt-${this.eventLog.length + 1}-${Date.now()}`;
    const payloadToSign = `${eventId}:${event.timestamp}:${event.actorId}:${event.scope}:${event.resourceTarget}:${event.rawInstructionText}`;
    const signature = createHmac('sha256', this.secretKey).update(payloadToSign).digest('hex');

    const signedEvent: RawExecutionEvent = {
      ...event,
      eventId,
      signature,
    };

    this.eventLog.push(signedEvent);
    this.projectClaimFromEvent(signedEvent);
    return signedEvent;
  }

  // 2. Deterministic State Projection: Mencegah semantic drift memory writer
  private projectClaimFromEvent(event: RawExecutionEvent): void {
    const eventHash = createHash('sha256').update(JSON.stringify(event)).digest('hex');
    const validUntil = event.conditions.ttlSeconds ? event.timestamp + event.conditions.ttlSeconds * 1000 : Infinity;

    const claim: GroundedMemoryClaim = {
      claimId: `claim-${event.eventId}`,
      sourceEventId: event.eventId,
      sourceEventHash: eventHash,
      scope: event.scope,
      resourceTarget: event.resourceTarget,
      validUntil,
      isRevoked: false,
      provenanceProof: `SHA256(${eventHash.slice(0, 16)}):${event.signature.slice(0, 16)}`,
    };

    const key = `${event.actorId}:${event.resourceTarget}:${event.scope}`;
    this.memoryClaims.set(key, claim);
  }

  // 3. Zero-Trust Executor Verification: Menolak klaim tanpa grounding valid
  public verifyAndAuthorizeAction(
    actorId: string,
    targetResource: string,
    requestedScope: ActionScope,
    currentTimestamp: number = Date.now()
  ): { authorized: boolean; reason: string; provenanceVerified: boolean } {
    const key = `${actorId}:${targetResource}:${requestedScope}`;
    const claim = this.memoryClaims.get(key);

    if (!claim) {
      return {
        authorized: false,
        reason: 'DENIED: No grounded memory claim found in state projection.',
        provenanceVerified: false,
      };
    }

    if (claim.isRevoked) {
      return {
        authorized: false,
        reason: 'DENIED: Permission claim has been revoked by tombstone event.',
        provenanceVerified: true,
      };
    }

    if (currentTimestamp > claim.validUntil) {
      return {
        authorized: false,
        reason: 'DENIED: Temporal authorization lease expired.',
        provenanceVerified: true,
      };
    }

    // Cari raw event di append-only log untuk validasi hash anti-laundering
    const rawEvent = this.eventLog.find((e) => e.eventId === claim.sourceEventId);
    if (!rawEvent) {
      return {
        authorized: false,
        reason: 'CRITICAL_SECURITY_ALERT: Orphaned claim detected! Endogenous authorization laundering blocked.',
        provenanceVerified: false,
      };
    }

    const recomputedHash = createHash('sha256').update(JSON.stringify(rawEvent)).digest('hex');
    if (recomputedHash !== claim.sourceEventHash) {
      return {
        authorized: false,
        reason: 'TAMPER_DETECTED: Source event hash mismatch. Claim invalidated.',
        provenanceVerified: false,
      };
    }

    return {
      authorized: true,
      reason: 'AUTHORIZED: Claim cryptographically verified against immutable execution provenance.',
      provenanceVerified: true,
    };
  }
}

4. Safety vs. Utility Tradeoff: Mengatasi Over-Rejection pada Autonomous Workflows

Penerapan sistem keamanan otorisasi yang sangat ketat (zero-trust provenance) memicu tantangan baru: Safety-Utility Tradeoff. Ketika validasi hak akses menuntut bukti kriptografis eksplisit untuk setiap tindakan kecil, agen dapat menolak instruksi sah (false rejection pada tugas yang membutuhkan improvisasi taktis).

• Just-In-Time (JIT) Escalation Gateway: Jika agen membutuhkan eskalasi izin yang tidak memiliki provenance dalam event log, agen tidak boleh merekayasa memori sendiri. Sistem harus menembakkan webhook JIT ke pengawas manusia (Human-in-the-Loop approval) dengan batas waktu konfirmasi (timeout 60 detik).
• Granular Scope Segregation: Memisahkan memori operasional (fakta teknis, catatan arsitektur, cache query) dari memori kebijakan (izin API key, kuota pengeluaran uang, hak modifikasi file). Agen dilarang menulis ke memori kebijakan tanpa tanda tangan modul policy-governance.
• Automated Provenance Auditing: Background daemon berkala yang memverifikasi integritas hash seluruh entri memori dan menghapus secara otomatis (prune) entri kadaluwarsa atau entri yang kehilangan rantai pembuktian (orphaned claims).

5. Panduan Implementasi untuk Arsitektur Modern 2026

Bagi rekayasawan perangkat lunak yang membangun sistem multi-agent di atas framework seperti Hermes Agent, LangGraph, atau CrewAI, berikut adalah langkah mitigasi yang harus segera diimplementasikan:

1. Hentikan Penggunaan Unstructured Free-Text Authorization: Jangan pernah menyimpan instruksi hak akses seperti "Admin memperbolehkan deploy" ke dalam file memori teks bebas (<code>MEMORY.md</code> atau database embedding teks) tanpa skema terstruktur.
2. Terapkan Typed Memory Schemas: Gunakan skema JSON-LD atau SQLite relational table dengan foreign key ke ID event transaksi asli.
3. Terapkan Strict TTL pada Otorisasi Sensitif: Berikan masa kedaluwarsa maksimal (default 15–60 menit) untuk tindakan berisiko tinggi (penghapusan data, modifikasi konfigurasi, eksekusi finansial).