Anatomi Serangan Sindikasi Konten AI

Endpoint publikasi publik (UGC/CMS ingestion) rentan terhadap bot sindikasi otomatis yang mengeksploitasi Large Language Models (LLM). Pola serangan ini memanen konten via scraping, menyusun ulang teks menggunakan LLM untuk menghindari plagiarisme verbatim, lalu membanjiri endpoint ingestion target demi kepentingan manipulasi SEO dan arbitrasi trafik.

Mengandalkan LLM eksternal untuk mendeteksi teks sintetis pada pipeline ingestion berisiko tinggi. Pendekatan tersebut menimbulkan latensi jaringan tambahan ratusan milidetik, biaya API per token yang membengkak, serta potensi false positive akibat sifat LLM yang non-deterministik. Mitigasi harus dilakukan pada lapisan infrastruktur dan middleware aplikasi menggunakan sinyal komputasi murah (low-compute heuristics).

Arsitektur Pertahanan Berlapis

Arsitektur pertahanan pipeline ingestion harus memvalidasi traffic dalam beberapa layer sebelum menyentuh storage layer atau database transaction:

  1. Layer 1 - Rate Limiting & Fingerprinting: Token bucket berbasis kombinasi IP subnet, JA4/TLS fingerprint, dan header entropy.
  2. Layer 2 - Heuristic Payload Analysis: Deteksi struktur teks repetitif melalui rasio kompresi zlib dan kalkulasi Shannon Entropy secara in-memory.
  3. Layer 3 - Locality-Sensitive Deduplication: MinHash LSH untuk mendeteksi variasi teks hasil parafrase para sindikat tanpa komparasi all-to-all.
  4. Layer 4 - Asymmetric Tarpit & Drop: Menahan koneksi klien anomali secara lambat tanpa membuka metadata moderasi ke pihak penyerang.

Deteksi Anomali Payload: Rasio Kompresi & Shannon Entropy

Teks alami bahasa manusia memiliki sebaran frekuensi karakter dan tingkat ketidakteraturan informasi yang dapat diprediksi. Teks boilerplate yang dihasilkan bot sindikasi—termasuk halusinasi repetitif atau format template prompt LLM—memiliki pola distribusi byte yang anomali.

  • Shannon Entropy: Mengukur densitas informasi dalam string. Nilai yang terlalu rendah (< 3.5 bit/karakter untuk teks latin) menandakan repetisi karakter atau kata yang ekstrem. Nilai yang terlalu tinggi (> 5.5 bit/karakter) menandakan payload terenkripsi, biner, atau teks terobfusikasi.
  • Rasio Kompresi Zlib: Rumus: R = CompressedSize / OriginalSize. Bahasa natural umumnya menghasilkan rasio kompresi antara 0.4 hingga 0.7. Generator teks otomatis berkualitas rendah sering kali mengulang struktur sintaksis yang menghasilkan rasio kompresi sangat ekstrem (< 0.25).

Implementasi Middleware Deteksi di Go

Berikut adalah implementasi middleware di Go untuk menghitung Shannon Entropy, rasio kompresi zlib, serta memicu respon tarpit untuk mematikan throughput bot penyerang.

package middleware

import (
	"bytes"
	"compress/zlib"
	"io"
	"math"
	"net/http"
	"time"
)

func PayloadHeuristicGuard(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost && r.Method != http.MethodPut {
			next.ServeHTTP(w, r)
			return
		}

		bodyBytes, err := io.ReadAll(r.Body)
		if err != nil || len(bodyBytes) == 0 {
			http.Error(w, "Bad Request", http.StatusBadRequest)
			return
		}
		// Restore body untuk handler berikutnya
		r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))

		// Evaluasi hanya teks berukuran signifikan (> 256 bytes)
		if len(bodyBytes) > 256 {
			entropy := calculateShannonEntropy(bodyBytes)
			ratio := calculateZlibRatio(bodyBytes)

			// Bot sindikasi: payload repetitif atau entropi rendah
			if entropy < 3.5 || ratio < 0.30 {
				executeTarpit(w)
				return
			}
		}

		next.ServeHTTP(w, r)
	})
}

func calculateShannonEntropy(data []byte) float64 {
	freq := make(map[byte]float64)
	for _, b := range data {
		freq[b]++
	}

	length := float64(len(data))
	var entropy float64
	for _, count := range freq {
		p := count / length
		entropy -= p * math.Log2(p)
	}
	return entropy
}

func calculateZlibRatio(data []byte) float64 {
	var b bytes.Buffer
	w := zlib.NewWriter(&b)
	_, _ = w.Write(data)
	_ = w.Close()

	return float64(b.Len()) / float64(len(data))
}

func executeTarpit(w http.ResponseWriter) {
	flusher, ok := w.(http.Flusher)
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusAccepted) // Opaque 202

	// Drain resource koneksi bot secara asimetris
	for i := 0; i < 5; i++ {
		time.Sleep(1200 * time.Millisecond)
		_, _ = w.Write([]byte(" "))
		if ok {
			flusher.Flush()
		}
	}
	_, _ = w.Write([]byte(`{"status":"queued"}`))
}

ponytail: Middleware membaca seluruh body ke memori; batasi request payload via http.MaxBytesReader sebelum middleware jika menangani ukuran file tak terbatas.

Deduplikasi Varian Sindikasi via MinHash LSH

Bot sindikasi tingkat lanjut menggunakan prompt rewrite agar hash kriptografis standar (SHA-256) berubah total. Pendekatan perbandingan teks string matching via Levenshtein Distance membutuhkan kompleksitas O(N*M) yang tidak dapat diskalakan pada pipeline data masif.

Solusinya adalah MinHash dengan Locality-Sensitive Hashing (LSH):

  1. Tokenisasi & Shingling: Ekstrak n-gram dari teks (contoh: k=5 kata).
  2. Hasing MinHash: Terapkan k fungsi hash independen untuk mengambil nilai minimum dari shingle set, menghasilkan tanda tangan berukuran tetap (misal: 64 atau 128 integer).
  3. Bandingkan Jaccard Similarity: Estimasi kemiripan teks dihitung dari jumlah kesamaan indeks signature MinHash dibagi total signature: J(A, B) ≈ Count(Sig_A[i] == Sig_B[i]) / k.

Simpan MinHash signatures di Redis dalam struktur data bitfield atau sorted sets berdasarkan bucket LSH. Jika skor Jaccard Similarity melampaui threshold 0.75 terhadap artikel yang dipublikasikan dalam 24 jam terakhir, gagalkan pemrosesan tanpa menulis ke primary database.

Strategi Respons dan Asymmetric Tarpit

Memberikan kode respons 400 Bad Request dengan deskripsi error rinci seperti "Content flagged as AI generated" hanya membantu penyerang mengoptimalkan parameter prompt mereka. Hindari membuka heuristik sistem.

1. Opaque Rejection (HTTP 202 Accepted)

Gunakan pola blackhole. Kembalikan kode status 202 Accepted dengan payload dummy (contoh: {"status":"pending_review"}). Di backend, buang payload secara instan tanpa memasukkannya ke antrean worker publikasi.

2. HTTP Tarpitting

Bot bergantung pada konkurensi scraping yang cepat. Tarpit memperlambat respon dengan mengirimkan chunk payload secara bertahap (drip-feed) selama beberapa detik. Ini memaksa worker pool milik bot mengalami starvation thread tanpa membebani thread server API berbasis event-driven (epoll/kqueue).

Limitasi dan Trade-off

  • Payload Berisi Kode Program: Potongan kode (JSON, SQL, Markdown blocks) memiliki rasio kompresi tinggi dan distribusi entropi yang berbeda dibanding prosa bahasa natural. Ekstrak kode sebelum menjalankan inspeksi heuristik.
  • Bahasa Non-Latin: Bahasa dengan set karakter multibyte (seperti CJK atau Cyrillic) memiliki batas entropi dasar berbeda dibanding teks berbasis ASCII/Latin. Tuning threshold per locale wajib dilakukan.
  • Overhead MinHash: Walau jauh lebih cepat dibanding perbandingan teks langsung, komputasi shingling tetap memakan CPU cycle. Jalankan MinHash secara asinkron via message queue jika throughput ingestion melebihi kapasitas thread HTTP.