Maraknya listing produk penipuan berbasis gambar generatif AI—seperti fenomena benih tanaman palsu yang diungkap oleh investigasi 404 Media—menunjukkan celah kritis pada arsitektur pipeline moderasi konten. Pada platform e-commerce skala besar, aset visual scam sering kali lolos bukan karena model computer vision gagal mendeteksi artefak sintetis, melainkan akibat kegagalan pada layer infrastruktur pengiriman data sebelum payload mencapai inference engine.

Gejala Masalah: Lonjakan Fraud Akibat Pipeline Timeout

Insiden bermula dari lonjakan listing produk hortikultura fiktif (misalnya mawar biru kristal atau stroberi ungu berpendar) yang berhasil dipublikasikan secara masif. Dari perspektif operasional, métrik sistem menunjukkan anomali berikut:

  • Tingkat penolakan otomatis (auto-rejection rate) turun drastis dari 8.4% ke 0.2% untuk kategori spesifik.
  • Metrik latensi p99 worker moderasi melonjak hingga menyentuh batas HTTP 504 Gateway Timeout.
  • Inference server eksternal tidak mencatat log aktivitas penilaian untuk gambar-gambar yang lolos, meskipun status listing di database berstatus APPROVED.

Analisis Root Cause

Investigasi log dan core dump mengidentifikasi dua celah struktural pada sistem backend:

1. Buffer Truncation pada Chunked Upload Parser

Aset gambar beresolusi tinggi diunggah menggunakan Transfer-Encoding: chunked. Node.js backend proxy mengonsumsi stream dan mengagregasi chunk sebelum di-forward ke model AI. Implementasi awal memotong buffer saat stream menerima event data melebihi batas window default tertentu tanpa memperhitungkan multipart boundary secara utuh. Akibatnya, gambar yang dikirim ke service AI Guard menghasilkan file JPEG/PNG rusak (corrupted binary), terutama pada bagian EOF marker.

2. Silent Error Handling dan Fail-Open pada Webhook

Ketika model AI menerima file corrupt, webhook worker mengembalikan response non-200 atau mengalami socket timeout. Implementasi worker menggunakan blok try/catch yang menelan error tersebut secara diam-diam (silent failure) dan mengasumsikan transaksi valid (fail-open) demi menghindari hambatan proses checkout merchant:

// Anti-pattern: Fail-open yang meloloskan scam payload
try {
  const result = await evaluateImageWithAi(imageBuffer);
  listing.isApproved = result.isClean;
} catch (error) {
  logger.warn('AI pipeline error, passing by default:', error.message);
  listing.isApproved = true; // ROOT CAUSE: Fail-open meloloskan payload bermasalah
}
await listing.save();

Panduan Perbaikan Langkah Demi Langkah

Langkah 1: Perbaikan Buffer Stream Parsing

Gunakan stream reader yang atomic dan terisolasi dengan validasi ukuran serta kelengkapan binary data sebelum proses dispatch ke inference pipeline.

import { Readable } from 'stream';

async function parseCompleteBuffer(stream: Readable, maxBytes: number): Promise<Buffer> {
  const chunks: Buffer[] = [];
  let totalSize = 0;

  for await (const chunk of stream) {
    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
    totalSize += buf.length;

    if (totalSize > maxBytes) {
      throw new Error('PAYLOAD_TOO_LARGE');
    }
    chunks.push(buf);
  }

  const completeBuffer = Buffer.concat(chunks, totalSize);
  
  // Validasi integritas minimal JPEG marker (SOI: 0xFFD8, EOI: 0xFFD9)
  if (completeBuffer.length < 4 || 
      completeBuffer[0] !== 0xFF || completeBuffer[1] !== 0xD8 ||
      completeBuffer[completeBuffer.length - 2] !== 0xFF || completeBuffer[completeBuffer.length - 1] !== 0xD9) {
    throw new Error('MALFORMED_IMAGE_BUFFER');
  }

  return completeBuffer;
}

Langkah 2: Terapkan Fallback Rejection Logic (Fail-Secure)

Sistem moderasi wajib menerapkan prinsip fail-secure. Jika terjadi kegagalan downstream API, pipeline parsing gagal, atau worker timeout, payload harus ditahan di antrean manual review (PENDING_REVIEW) atau langsung ditolak (REJECTED), bukan dipublikasikan.

// Penerapan Fail-Secure Logic
try {
  const imageBuffer = await parseCompleteBuffer(req, 10 * 1024 * 1024);
  const decision = await callAiGuardService(imageBuffer);
  listing.status = decision.isScam ? 'REJECTED' : 'APPROVED';
} catch (error) {
  logger.error('Moderation failure, quarantine asset:', { error: error.message, listingId: listing.id });
  listing.status = 'QUARANTINE';
  await pushToManualReviewQueue(listing.id);
} finally {
  await listing.save();
}

Langkah 3: Boundary Payload Unit Test

Verifikasi bahwa parser memvalidasi fragmentasi chunk dan menangani kegagalan downstream secara deterministik.

import { Readable } from 'stream';
import assert from 'assert';

async function runBoundaryTest() {
  // Simulasi stream terpotong tanpa EOI marker
  const corruptedStream = Readable.from([
    Buffer.from([0xFF, 0xD8, 0x00, 0x10]),
    Buffer.from([0x4A, 0x46, 0x49, 0x46])
  ]);

  let caughtError: Error | null = null;
  try {
    await parseCompleteBuffer(corruptedStream, 1024);
  } catch (err: any) {
    caughtError = err;
  }

  assert(caughtError !== null, 'Buffer stream harus gagal jika EOI marker tidak ditemukan');
  assert.strictEqual(caughtError?.message, 'MALFORMED_IMAGE_BUFFER');
  console.log('Boundary test passed: Malformed chunk berhasil dicegat.');
}

runBoundaryTest();

Langkah 4: Tracing Latensi Async Worker Menggunakan OpenTelemetry

Untuk melacak bottleneck p99 pada chunk parsing dan call HTTP service AI, distribusikan context tracing ke antrean async (misal: BullMQ atau RabbitMQ):

import { trace, SpanStatusCode } from '@opentelemetry/api';

const tracer = trace.getTracer('ai-guard-pipeline');

async function processModerationJob(job: { data: { listingId: string, payloadUrl: string } }) {
  return tracer.startActiveSpan('processModerationJob', async (span) => {
    try {
      span.setAttribute('listing.id', job.data.listingId);
      
      const fetchSpan = tracer.startSpan('downloadPayload');
      const buffer = await downloadImage(job.data.payloadUrl);
      fetchSpan.end();

      const aiSpan = tracer.startSpan('evaluateAiInference');
      const result = await callAiGuardService(buffer);
      aiSpan.end();

      span.setStatus({ code: SpanStatusCode.OK });
    } catch (err: any) {
      span.recordException(err);
      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
      throw err;
    } finally {
      span.end();
    }
  });
}

Kesimpulan

Bypass moderasi gambar sintetis sering kali bukan kelemahan algoritma computer vision, melainkan kerapuhan rekayasa pipeline penanganan data di upstream. Dengan beralih dari pola fail-open ke fail-secure, memperbaiki parsing chunked upload secara utuh, dan memantau distributed spans menggunakan tracing, sistem e-commerce dapat membendung infiltrasi aset scam sebelum sempat dipublikasikan.