2026-10-31 · 12 min
Berburu Zombie API: Endpoint dan Kode Mati yang Masih Hidup
Malam ini Halloween, dan sekaligus hari terakhir Cybersecurity Awareness Month. Jadi saya menutup bulan dengan perburuan yang paling cocok untuk tanggal 31 Oktober: berburu zombie. Bukan yang di film, tapi zombie API, yaitu endpoint yang sudah dinyatakan mati, deprecated, atau tidak pernah tercatat di dokumentasi, tetapi masih menerima trafik di production. OWASP memasukkan masalah ini ke daftar risiko resminya dengan nama yang kurang seram tapi jauh lebih tepat: Improper Inventory Management. Artikel ini adalah tutorial api inventory management owasp yang bisa langsung dijalankan di service TypeScript Anda.
Sebagai reviewer dev tool, saya tidak tertarik pada daftar periksa yang berakhir dengan “lakukan audit secara berkala”. Saya ingin kriteria. Jadi di akhir tulisan ini, setiap endpoint yang Anda temukan harus jatuh ke salah satu dari tiga keputusan: hapus, kunci, atau sunset. Tidak ada kategori “nanti dilihat lagi”, karena kategori itulah yang melahirkan zombie.
Alurnya empat langkah:
- Ambil tabel route runtime, yaitu apa yang benar-benar didaftarkan aplikasi saat jalan.
- Bandingkan dengan spec OpenAPI, yaitu apa yang Anda klaim ada.
- Silangkan dengan access log, yaitu apa yang benar-benar dipanggil orang.
- Setelah route dicabut, jalankan Knip untuk membersihkan kode dan dependency yang ikut mati.
Kenapa Zombie API Masuk OWASP API Security Top 10
Di OWASP API Security Top 10 edisi 2023, risiko ini tercatat sebagai API9:2023 Improper Inventory Management. Polanya hampir selalu sama: versi baru dirilis dengan otorisasi yang lebih ketat, validasi input yang lebih baik, dan rate limit. Versi lama “akan dimatikan nanti”. Nanti itu tidak pernah datang, dan versi lama tetap menjawab request dengan semua kelemahan yang sudah diperbaiki di versi baru.
Penyerang tidak perlu menemukan celah di /v2. Cukup mencoba /v1, atau /internal/debug/... yang dulu dipakai untuk troubleshooting dan lupa dicabut. OWASP menyebut dua titik buta: documentation blindspot, ketika tim tidak tahu endpoint apa saja yang terbuka, dan data flow blindspot, ketika data mengalir ke pihak ketiga tanpa catatan. Tutorial ini fokus ke yang pertama, di level satu service. Inventaris host seperti subdomain staging, beta, atau sandbox yang terbuka ke internet tetap perlu dicek terpisah dengan kriteria yang sama.
Agar istilahnya konsisten, saya pakai pembagian ini:
| Istilah | Ada di runtime | Ada di spec | Ada trafik |
|---|---|---|---|
| Endpoint sehat | Ya | Ya, tidak deprecated | Ya |
| Yatim (shadow API) | Ya | Tidak | Ya atau tidak |
| Zombie | Ya | Ya, deprecated: true | Ya |
| Nisan kosong | Tidak | Ya | Tidak |
Kolom terakhir itulah yang membedakan teori dan kenyataan. Tanpa access log, Anda hanya menebak.
Langkah 1: Ambil Tabel Route dari Aplikasi yang Sedang Jalan
Sumber kebenaran pertama adalah aplikasi itu sendiri, bukan README dan bukan ingatan tim. Contoh di sini memakai Fastify, karena Fastify punya hook onRoute yang terdokumentasi dan terpanggil setiap kali route didaftarkan, termasuk route di dalam plugin. Framework lain punya padanannya: NestJS dengan DiscoveryService, Hono dengan app.routes, dan seterusnya.
Pertama, pastikan aplikasi dibangun lewat factory function, sehingga skrip bisa memasang hook sebelum route terdaftar:
// src/app.ts
import Fastify, { type RouteOptions } from 'fastify';
import { sunsetHook } from './plugins/sunset.js';
import { registerRoutes } from './routes/index.js';
export function buildApp(opts: { onRoute?: (r: RouteOptions) => void } = {}) {
const app = Fastify({ logger: process.env.NODE_ENV === 'production' });
if (opts.onRoute) app.addHook('onRoute', opts.onRoute);
sunsetHook(app);
app.register(registerRoutes);
return app;
}
sunsetHook akan kita tulis di langkah 5. Kalau Anda belum membutuhkannya, hapus dua barisnya dulu.
Lalu skrip yang membangun aplikasi tanpa listen, mengumpulkan semua route, dan menulisnya ke JSON. Path parameter gaya Fastify (:id) langsung diubah ke gaya OpenAPI ({id}) supaya bisa dibandingkan:
// scripts/dump-routes.ts
import { mkdirSync, writeFileSync } from 'node:fs';
import { buildApp } from '../src/app.js';
type RuntimeRoute = { method: string; path: string };
const routes: RuntimeRoute[] = [];
const app = buildApp({
onRoute(route) {
const methods = Array.isArray(route.method) ? route.method : [route.method];
for (const method of methods) {
// HEAD dibuat otomatis oleh Fastify untuk setiap GET, tidak perlu dicatat
if (method === 'HEAD' || method === 'OPTIONS') continue;
routes.push({ method, path: route.url.replace(/:(\w+)/g, '{$1}') });
}
},
});
await app.ready();
mkdirSync('inventory', { recursive: true });
writeFileSync('inventory/runtime-routes.json', JSON.stringify(routes, null, 2));
console.log(`${routes.length} route tercatat`);
await app.close();
Jalankan dengan npx tsx scripts/dump-routes.ts. Skrip ini memakai top-level await, jadi package.json perlu "type": "module". Dua batasan yang perlu Anda tahu: route dengan regex di parameter (misalnya :id(^\\d+)) dan wildcard * tidak akan dinormalisasi dengan rapi oleh satu baris replace itu. Kalau service Anda memakainya, tambahkan normalisasi sendiri.
Langkah 2 dan 3: Silangkan dengan Spec OpenAPI dan Access Log
Sekarang skrip intinya. Ia membaca tiga sumber: inventory/runtime-routes.json, openapi.yaml, dan access log nginx format combined dari stdin. Hasilnya satu tabel status per endpoint.
Satu keputusan desain yang penting: runtime adalah acuan pencocokan trafik, bukan spec. Spec bisa bohong, aplikasi yang sedang jalan tidak.
// scripts/audit-inventory.ts
import { readFileSync } from 'node:fs';
import { createInterface } from 'node:readline';
import { parse } from 'yaml';
// Isi '/v1' kalau base path ada di servers[].url dan tidak ditulis di paths
const SPEC_PREFIX = '';
const METHODS = ['get', 'put', 'post', 'delete', 'patch'] as const;
type RuntimeRoute = { method: string; path: string };
const runtime: RuntimeRoute[] = JSON.parse(
readFileSync('inventory/runtime-routes.json', 'utf8'),
);
// 1. Operasi yang tercatat di spec OpenAPI
const spec = parse(readFileSync('openapi.yaml', 'utf8'));
const specOps = new Map<string, { deprecated: boolean }>();
for (const [path, item] of Object.entries<any>(spec.paths ?? {})) {
for (const m of METHODS) {
if (item?.[m]) {
specOps.set(`${m.toUpperCase()} ${SPEC_PREFIX}${path}`, {
deprecated: item[m].deprecated === true,
});
}
}
}
// 2. Ubah template route jadi regex; yang paling spesifik dicocokkan duluan
const escape = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
const matchers = runtime
.map((r) => {
const segs = r.path.split('/').filter(Boolean);
const body = segs.map((s) => (s.startsWith('{') ? '[^/]+' : escape(s))).join('/');
return {
key: `${r.method} ${r.path}`,
method: r.method,
re: new RegExp(`^/${body}/?$`),
staticSegs: segs.filter((s) => !s.startsWith('{')).length,
};
})
.sort((a, b) => b.staticSegs - a.staticSegs);
// 3. Hitung trafik dari access log format combined nginx (dibaca dari stdin)
const LINE = /"([A-Z]+) ([^ "?]+)[^"]*"/;
const hits = new Map<string, number>();
const unmatched = new Map<string, number>();
const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
for await (const line of rl) {
const m = LINE.exec(line);
if (!m) continue;
const method = m[1] === 'HEAD' ? 'GET' : m[1];
const path = m[2];
const hit = matchers.find((x) => x.method === method && x.re.test(path));
if (hit) hits.set(hit.key, (hits.get(hit.key) ?? 0) + 1);
else unmatched.set(`${method} ${path}`, (unmatched.get(`${method} ${path}`) ?? 0) + 1);
}
// 4. Gabungkan tiga sumber jadi satu tabel status
type Row = { endpoint: string; status: string; hits: number };
const rows: Row[] = [];
const runtimeKeys = new Set(runtime.map((r) => `${r.method} ${r.path}`));
for (const key of runtimeKeys) {
const op = specOps.get(key);
const n = hits.get(key) ?? 0;
let status: string;
if (!op) status = n > 0 ? 'YATIM-AKTIF' : 'YATIM-SEPI';
else if (op.deprecated) status = n > 0 ? 'ZOMBIE' : 'DEPRECATED-SEPI';
else status = n > 0 ? 'OK' : 'SEPI';
if (status !== 'OK') rows.push({ endpoint: key, status, hits: n });
}
for (const key of specOps.keys()) {
if (!runtimeKeys.has(key)) rows.push({ endpoint: key, status: 'SPEC-TANPA-ROUTE', hits: 0 });
}
rows.sort((a, b) => b.hits - a.hits);
console.table(rows);
const top = [...unmatched].sort((a, b) => b[1] - a[1]).slice(0, 10);
console.log('Request yang tidak cocok dengan route mana pun (top 10):');
console.table(top.map(([endpoint, n]) => ({ endpoint, n })));
// Mode CI: gagal kalau ada route yang tidak terdokumentasi di spec
if (process.env.CI && rows.some((r) => r.status.startsWith('YATIM'))) {
console.error('Ada endpoint yatim. Dokumentasikan di openapi.yaml atau hapus route-nya.');
process.exitCode = 1;
}
Beberapa detail yang sengaja saya pilih:
- Urutan pencocokan berdasarkan jumlah segmen statis. Tanpa ini, request
GET /v2/users/mebisa terhitung sebagaiGET /v2/users/{id}, dan hitungan trafik Anda salah. - HEAD dihitung sebagai GET, karena Fastify melayani HEAD lewat route GET yang sama.
- Log dibaca dari stdin, jadi Anda bebas menggabungkan file rotasi. Di server Linux, misalnya:
zcat -f /var/log/nginx/access.log* | npx tsx scripts/audit-inventory.ts. - Paket
yamldipasang sebagai devDependency (npm i -D yaml tsx), karena hanya dipakai skrip audit.
Hati-hati dengan retensi log. Di banyak distro Linux, konfigurasi logrotate bawaan nginx hanya menyimpan sekitar dua minggu. Cek /etc/logrotate.d/nginx sebelum menyimpulkan endpoint “tidak pernah dipanggil”. Kalau Anda punya API gateway, load balancer dengan access log, atau APM, data dari sana biasanya lebih panjang dan lebih bisa dipercaya.
Contoh output di service uji saya terlihat seperti ini:
┌─────────┬────────────────────────────────┬────────────────────┬──────┐
│ (index) │ endpoint │ status │ hits │
├─────────┼────────────────────────────────┼────────────────────┼──────┤
│ 0 │ 'GET /v1/users/{id}' │ 'ZOMBIE' │ 2 │
│ 1 │ 'POST /internal/debug/reindex' │ 'YATIM-AKTIF' │ 1 │
│ 2 │ 'GET /health' │ 'YATIM-AKTIF' │ 1 │
│ 3 │ 'GET /v2/orders' │ 'SPEC-TANPA-ROUTE' │ 0 │
└─────────┴────────────────────────────────┴────────────────────┴──────┘
Empat baris, empat cerita berbeda. GET /v1/users/{id} sudah ditandai deprecated tapi masih dipanggil: zombie klasik. POST /internal/debug/reindex tidak ada di spec dan dipanggil dari luar: ini yang paling mengkhawatirkan. GET /health juga yatim, tapi wajar, karena ini endpoint infrastruktur untuk load balancer. Untuk kasus seperti ini, dokumentasikan di spec dengan tag internal atau buat allowlist eksplisit di skrip, supaya mode CI tidak berbunyi tanpa alasan. GET /v2/orders adalah nisan kosong: dijanjikan di spec, tidak pernah ada di aplikasi.
Tabel kedua, request yang tidak cocok dengan route mana pun, juga layak dibaca. Kalau isinya /.env atau /wp-login.php, itu scanner biasa. Tapi kalau ada pola seperti /api/v0/... yang dulu pernah ada, berarti masih ada client lama yang mencoba, atau ada service lain di belakang domain yang sama yang belum masuk inventaris Anda.
Langkah 4: Kriteria Tegas, Hapus, Kunci, atau Sunset
Ini bagian yang paling sering dilewati, padahal di sinilah zombie benar-benar dibasmi. Aturan saya: cek keamanan dulu, baru trafik. Endpoint yang berbahaya dikunci hari ini, berapa pun trafiknya.
| Keputusan | Syarat (semua harus terpenuhi, kecuali disebut lain) | Tindakan |
|---|---|---|
| Kunci (hari ini) | Salah satu: endpoint debug atau internal terbuka ke publik; kontrol keamanannya lebih lemah dari versi pengganti (otorisasi per objek, rate limit, validasi input); atau yatim aktif dengan consumer yang tidak dikenal | Pindahkan ke jaringan internal atau allowlist IP, pasang auth dan otorisasi yang sama dengan versi baru, rate limit ketat, log identitas pemanggil |
| Sunset | Consumer dikenal, ada endpoint pengganti, dan endpoint lama tidak punya celah keamanan yang belum ditambal | Pasang header Deprecation dan Sunset, hubungi consumer, kembalikan 410 Gone setelah tanggal sunset |
| Hapus | Nol trafik selama jendela observasi (minimal 30 hari dan mencakup siklus bisnis terpanjang), tidak ada consumer di daftar kontrak, owner service menyetujui; atau tanggal sunset sudah lewat dan 410 sudah berjalan beberapa waktu | Cabut route, lalu bersihkan sisa kodenya dengan Knip |
Status lain dari skrip punya jawaban yang sama tegasnya:
- SPEC-TANPA-ROUTE: perbaiki spec hari ini. Dokumentasi palsu membuat tim lain generate client ke endpoint yang tidak ada.
- SEPI (terdokumentasi, nol trafik): jangan langsung dihapus. Tanyakan ke owner apakah endpoint itu musiman. Kalau tidak ada yang bisa menjawab, perlakukan sebagai kandidat sunset.
- DEPRECATED-SEPI: kandidat hapus terkuat, asalkan jendela observasinya cukup panjang.
Untuk yatim aktif dengan consumer yang tidak dikenal, ada satu teknik lanjutan yang dipakai beberapa penyedia API besar saat mempensiunkan fitur: brownout, yaitu mematikan endpoint sementara di jam yang diumumkan, misalnya 30 menit, supaya consumer yang tersembunyi muncul dan melapor. Lakukan hanya setelah endpoint dikunci dan pemanggilnya tercatat di log, dan umumkan jadwalnya lebih dulu.
Langkah 5: Deprecated Endpoint, Sunset Header, dan 410 Gone
Ada dua header standar untuk mengomunikasikan pensiun endpoint. Sunset (RFC 8594) berisi tanggal endpoint berhenti melayani, dalam format HTTP-date. Deprecation (RFC 9745, terbit 2025) menyatakan sejak kapan endpoint deprecated, dalam format tanggal Structured Field, yaitu @ diikuti Unix timestamp. Keduanya bisa dilengkapi header Link dengan relasi deprecation dan sunset yang menunjuk ke dokumen migrasi.
Kalau Anda pernah membaca tulisan kami soal strategi versioning API, contohnya masih memakai Deprecation: true dari masa draft. Untuk implementasi baru, ikuti format RFC 9745.
Hook di bawah membaca template route yang cocok, bukan URL mentah, lalu memasang header atau mengembalikan 410 setelah tanggal sunset lewat:
// src/plugins/sunset.ts
import type { FastifyInstance } from 'fastify';
type SunsetPolicy = {
deprecatedAt: Date;
sunsetAt: Date;
successor: string;
docs: string;
};
export const SUNSET: Record<string, SunsetPolicy> = {
'GET /v1/users/{id}': {
deprecatedAt: new Date('2026-08-01T00:00:00Z'),
sunsetAt: new Date('2027-01-31T23:59:59Z'),
successor: '/v2/users/{id}',
docs: 'https://docs.example.com/migrasi/users-v1-ke-v2',
},
};
export function sunsetHook(app: FastifyInstance) {
app.addHook('onRequest', async (req, reply) => {
const template = req.routeOptions.url; // contoh: /v1/users/:id
if (!template) return;
const key = `${req.method} ${template.replace(/:(\w+)/g, '{$1}')}`;
const policy = SUNSET[key];
if (!policy) return;
if (Date.now() >= policy.sunsetAt.getTime()) {
return reply.code(410).send({
error: 'Gone',
message: 'Endpoint ini sudah dipensiunkan.',
successor: policy.successor,
docs: policy.docs,
});
}
reply.header('Deprecation', `@${Math.floor(policy.deprecatedAt.getTime() / 1000)}`);
reply.header('Sunset', policy.sunsetAt.toUTCString());
reply.header('Link', `<${policy.docs}>; rel="deprecation", <${policy.docs}>; rel="sunset"`);
req.log.warn(
{ deprecatedRoute: key, userAgent: req.headers['user-agent'] },
'endpoint deprecated masih dipanggil',
);
});
}
Response dari endpoint zombie kini membawa header seperti ini:
Deprecation: @1785542400
Sunset: Sun, 31 Jan 2027 23:59:59 GMT
Link: <https://docs.example.com/migrasi/users-v1-ke-v2>; rel="deprecation", <https://docs.example.com/migrasi/users-v1-ke-v2>; rel="sunset"
Tiga hal yang membuat pola ini lebih dari sekadar kosmetik:
- Header tidak menegakkan apa pun. Sunset header hanya janji. Yang membuat zombie benar-benar mati adalah cabang
410 Goneitu, yang aktif sendiri tanpa perlu deploy ulang di tanggal sunset. - Log warning adalah daftar consumer Anda. Kumpulkan
userAgent, dan kalau ada, ID API key atau client ID. Daftar itulah yang Anda hubungi satu per satu sebelum tanggal sunset. - Kebijakan tinggal di satu tempat. Satu objek
SUNSETbisa di-review di PR, dan jejaknya bisa dibaca auditor.
Jangan lupa tandai juga operasi yang sama dengan deprecated: true di openapi.yaml, supaya skrip audit di langkah 2 mengenalinya sebagai zombie, bukan yatim. Kalau tim Anda sudah memakai alur OpenAPI spec-first, perubahan ini sebaiknya masuk spec lebih dulu, baru kodenya.
Langkah 6: Knip untuk Dead Code TypeScript yang Ikut Mati
Setelah route dicabut, zombie belum benar-benar dikubur. Handler-nya masih ada, helper yang hanya dipakai handler itu masih ada, dan library yang dulu dipasang khusus untuk v1 masih ada di package.json. Setiap dependency yang tersisa adalah permukaan serangan rantai pasok yang tidak memberi manfaat apa pun. Di sinilah saya memakai Knip.
Pick saya untuk knip dead code typescript jelas: Knip, bukan ts-prune. README ts-prune sendiri sudah menyatakan proyeknya dalam mode maintenance dan mengarahkan pengguna ke Knip. Knip juga lebih lengkap, karena sekaligus memeriksa file yatim, export yang tidak terpakai, dan dependency yang tidak dipakai, dengan plugin untuk banyak tool populer.
Tapi ada satu batasan penting yang perlu dipahami sebelum memakainya: Knip tidak bisa menemukan zombie API. Knip membaca graf import secara statis. Handler yang didaftarkan ke router selalu terlihat terpakai, sekalipun tidak ada satu manusia pun yang memanggil endpoint-nya. Lebih buruk lagi, kalau route Anda dimuat dinamis lewat @fastify/autoload, Anda harus mendaftarkan folder routes sebagai entry, dan sejak itu Knip menganggap semua file di sana hidup. Karena itu urutannya tidak bisa dibalik: data runtime dan log dulu, Knip sesudahnya.
Pasang dan konfigurasi:
npm i -D knip
{
"$schema": "https://unpkg.com/knip@6/schema.json",
"entry": ["src/server.ts!", "scripts/*.ts"],
"project": ["src/**/*.ts!", "scripts/**/*.ts"]
}
Simpan sebagai knip.json di root repo. Sesuaikan angka versi di URL $schema dengan versi mayor Knip yang terpasang. Tanda ! di akhir pola menandai file production, sehingga mode --production hanya menganalisis kode yang benar-benar ikut ke server.
Setelah route legacy dicabut dari src/routes/index.ts, menjalankan npx knip di service uji saya menghasilkan:
Unused files (1)
src/routes/legacy.ts
Unused dependencies (1)
lodash package.json:4:6
Unused exports (1)
SUNSET src/plugins/sunset.ts:10:14
Cara membacanya dengan kriteria:
- Unused files: handler yang ditinggal route-nya. Hapus, karena sumber kebenarannya sudah diputuskan di langkah 4.
- Unused dependencies: library yang hanya dipakai kode legacy. Hapus dari
package.json, lalu jalankan ulang test. - Unused exports:
SUNSEThanya dipakai di dalam file-nya sendiri. Ini bukan kode mati, hanya export yang tidak perlu. Hapus kata kunciexport-nya, atau biarkan kalau Anda memang berencana mengujinya dari luar.
Jalankan juga npx knip --production. Di service uji saya, yaml sempat terpasang di dependencies, dan mode ini langsung menandainya sebagai tidak dipakai di kode production. Itu benar: yaml hanya dipakai skrip audit, jadi tempatnya di devDependencies. Temuan seperti ini memperkecil isi image production tanpa mengubah perilaku apa pun.
Knip punya --fix yang menghapus kata kunci export dan entri dependency secara otomatis, plus --allow-remove-files untuk ikut menghapus file. Aturan saya: jalankan --fix hanya di branch tersendiri, review diff-nya baris per baris, dan jangan pernah memakai --allow-remove-files di CI. Knip keluar dengan exit code 1 kalau menemukan masalah, jadi untuk CI cukup jalankan npx knip sebagai satu langkah pipeline.
Pasang Penjaga agar Zombie Tidak Bangkit Lagi
Perburuan satu malam tidak ada artinya kalau minggu depan muncul endpoint yatim baru. Tiga penjaga yang saya pasang di pipeline:
- Mode CI skrip audit. Jalankan dump route lalu audit dengan stdin kosong, misalnya
npx tsx scripts/dump-routes.ts && CI=1 npx tsx scripts/audit-inventory.ts < /dev/null. Tanpa log, semua hit bernilai nol, tapi status YATIM tetap terdeteksi, dan build gagal kalau ada route baru yang tidak masuk spec. npx knipdi setiap PR, supaya kode dan dependency mati tidak menumpuk lagi.- Audit trafik bulanan dengan log sungguhan, di tanggal yang sama setiap bulan. Hasilnya masuk ke tiket dengan salah satu dari tiga label: hapus, kunci, sunset.
Checklist Tutup Bulan: Malam Halloween Ini
Kalau Anda hanya punya satu malam untuk menutup Cybersecurity Awareness Month, kerjakan urutan ini:
- Dump route runtime dari setiap service yang menghadap internet.
- Jalankan skrip audit terhadap spec OpenAPI dan log minimal 30 hari.
- Kunci semua endpoint debug, internal, dan yatim aktif yang tidak jelas pemakainya, malam ini juga.
- Pasang
Deprecation,Sunset, dan penegakan410 Goneuntuk setiap zombie yang punya pengganti. - Perbaiki spec untuk setiap baris SPEC-TANPA-ROUTE.
- Cabut route yang memenuhi syarat hapus, lalu jalankan Knip dan bersihkan sisanya.
- Pasang mode CI skrip audit dan Knip agar hasilnya bertahan.
Ukuran keberhasilannya sederhana: tabel dari skrip audit hanya berisi baris yang statusnya sudah diputuskan, dan tidak ada satu pun endpoint di production yang tidak bisa Anda jelaskan siapa pemiliknya, siapa pemakainya, dan kapan ia akan mati. Zombie hanya menakutkan selama tidak ada yang menghitungnya.
Ditulis oleh Asti Larasati