Dalam arsitektur aplikasi modern, antarmuka pemrograman aplikasi (API) telah menjadi tulang punggung yang menghubungkan sistem backend dengan aplikasi web Single Page Application (SPA), aplikasi seluler, dan ekosistem mitra B2B. Namun, seiring terbukanya endpoint-endpoint tersebut ke publik, API kini menjadi sasaran utama dari lebih dari 80% serangan siber yang menargetkan lapisan aplikasi.
Banyak tim pengembang merasa aman karena sudah menerapkan Web Application Firewall (WAF) atau gateway jaringan. Sayangnya, WAF konvensional dirancang untuk mendeteksi pola serangan injeksi berbasis teks (seperti SQL Injection atau Cross-Site Scripting klasik), dan sering kali buta terhadap kerentanan logika bisnis (business logic flaws) yang menjadi ciri khas dari daftar OWASP API Security Top 10.
Artikel ini membedah empat kerentanan paling kritis dalam OWASP API Top 10 serta langkah mitigasi teknis konkret pada backend Node.js (TypeScript) dan Go.
Anatomi Kerentanan Logika Bisnis API:
1. Broken Object Level Authorization (BOLA):
Klien (User A) ──► GET /api/v1/invoices/9924 ──► Backend
[Celah: Backend hanya memeriksa "Apakah User A sudah login?",
TETAPI TIDAK memeriksa "Apakah Invoice 9924 milik User A?"]
──► Data Finansial Perusahaan Lain Bocor!
2. Mass Assignment (Broken Property Authorization):
Klien (User Biasa) ──► PATCH /api/v1/users/profile
Body: { "nama": "Budi", "role": "SUPERADMIN" }
[Celah: Backend langsung memetakan seluruh properti JSON ke Model Database]
──► Eskalasi Hak Akses Ilegal Berhasil!
1. API1:2023 Broken Object Level Authorization (BOLA / IDOR) #
BOLA (dikenal juga sebagai Insecure Direct Object References) menempati peringkat pertama sebagai celah keamanan paling sering dieksploitasi. Masalah ini terjadi ketika endpoint menerima ID objek dari input klien (misalnya path parameter /api/orders/{id}) dan mengakses objek tersebut tanpa memvalidasi apakah pengguna yang sedang login memiliki hak kepemilikan atas objek yang diminta.
Pola Kode Rentan (Anti-Pattern): #
// BAHAYA: Mengambil data hanya berdasarkan ID dari parameter URL
app.get('/api/orders/:orderId', async (req, res) => {
const order = await db.orders.findById(req.params.orderId);
if (!order) return res.status(404).send('Pesanan tidak ditemukan');
// Penyerang cukup mengubah orderId dari 1001 ke 1002 untuk mengintip data orang lain!
return res.json(order);
});
Pola Mitigasi yang Benar: #
Validasi otorisasi kepemilikan wajib ditegakkan langsung di dalam klausa query basis data:
// AMAN: Memaksa filter kepemilikan tenant/user di tingkat database
app.get('/api/orders/:orderId', authenticateToken, async (req, res) => {
const currentUserId = req.user.id;
const currentTenantId = req.user.tenantId;
const order = await db.query(
`SELECT id, total_amount, status, created_at
FROM orders
WHERE id = $1 AND tenant_id = $2 AND customer_id = $3`,
[req.params.orderId, currentTenantId, currentUserId]
);
if (order.rows.length === 0) {
// Gunakan 404 alih-alih 403 agar penyerang tidak dapat melakukan enumerasi keberadaan ID
return res.status(404).json({ error: 'Pesanan tidak ditemukan' });
}
return res.json(order.rows[0]);
});
2. API3:2023 Broken Object Property Level Authorization (Mass Assignment) #
Kerentanan ini terjadi ketika backend secara membabi-buta menyalin seluruh properti dari payload JSON permintaan klien langsung ke dalam model database atau entitas ORM tanpa penyaringan atribut ketat (property whitelisting).
Mitigasi Menggunakan Validasi Skema Ketat (Zod): #
Jangan pernah menerima objek mentah req.body. Gunakan library validasi skema untuk membuang properti tak dikenal (strip unknown fields):
import { z } from 'zod';
// Definisikan skema atribut yang HANYA boleh diubah oleh pengguna
const UpdateProfileSchema = z.object({
fullName: z.string().min(2).max(100),
phoneNumber: z.string().regex(/^[0-9+]+$/).max(20),
address: z.string().max(255).optional(),
}).strict(); // .strict() akan menolak permintaan jika ada properti tak dikenal
export async function updateProfileHandler(req: any, res: any) {
const parseResult = UpdateProfileSchema.safeParse(req.body);
if (!parseResult.success) {
return res.status(400).json({ errors: parseResult.error.format() });
}
// Hanya data yang sudah divalidasi dan lolos whitelist yang diproses
const cleanData = parseResult.data;
await db.users.update({ where: { id: req.user.id }, data: cleanData });
return res.json({ message: 'Profil berhasil diperbarui' });
}
3. API4:2023 Unrestricted Resource Consumption #
Celah ini terjadi ketika API tidak membatasi kuota konsumsi sumber daya komputasi atau memori, memungkinkan penyerang melumpuhkan server melalui Denial of Service (DoS):
- Meminta pagination raksasa:
/api/transactions?limit=10000000yang menyebabkan memori RAM server meledak. - Mengirimkan operasi komputasi berat tanpa batas frekuensi.
Mitigasi Paginasi dan Rate Limiting: #
- Tetapkan batas atas mutlak (hard cap) pada parameter paginasi (misal maksimal 100 entri per halaman).
- Terapkan sliding window rate limiter di tingkat API Gateway atau middleware:
// Middleware pembatasan paginasi defensif
export function enforcePaginationLimits(req: any, res: any, next: any) {
let limit = parseInt(req.query.limit, 10) || 20;
if (limit > 100) limit = 100; // Hard cap maksimal 100
if (limit < 1) limit = 1;
req.sanitizedPagination = {
limit,
page: Math.max(1, parseInt(req.query.page, 10) || 1),
};
next();
}
4. API7:2023 Server-Side Request Forgery (SSRF) #
SSRF terjadi ketika API menyediakan fitur yang memicu server membuat panggilan HTTP ke URL yang disediakan oleh pengguna (seperti fitur pengujian Webhook, preview tautan URL, atau import data dari tautan eksternal).
Penyerang dapat memasukkan alamat IP internal untuk mencuri kredensial cloud:
http://169.254.169.254/latest/meta-data/(Metadata server AWS/GCP yang memuat secret IAM role).http://127.0.0.1:6379(Mengirimkan payload teks ke server Redis lokal di dalam jaringan privat).
Mitigasi Validasi IP Defensif pada Go: #
Validasi tidak cukup hanya memeriksa string nama domain, karena penyerang dapat menggunakan teknik DNS Rebinding. Server wajib me-resolve alamat IP terlebih dahulu dan memblokir seluruh rentang IP privat sebelum koneksi TCP dibuat:
package main
import (
"errors"
"net"
"net/http"
"time"
)
// IsPrivateIP memeriksa apakah IP berada di rentang privat RFC 1918 atau loopback
func IsPrivateIP(ip net.IP) bool {
if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() {
return true
}
privateCIDRs := []string{
"10.0.0.0/8",
"172.16.0.0/12",
"192.168.0.0/16",
"169.254.0.0/16", // AWS / Cloud Metadata
}
for _, cidr := range privateCIDRs {
_, block, _ := net.ParseCIDR(cidr)
if block.Contains(ip) {
return true
}
}
return false
}
// CreateSafeHTTPClient mengembalikan klien HTTP anti-SSRF
func CreateSafeHTTPClient() *http.Client {
return &http.Client{
Timeout: 5 * time.Second,
Transport: &http.Transport{
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
host, port, _ := net.SplitHostPort(addr)
ips, err := net.LookupIP(host)
if err != nil {
return nil, err
}
for _, ip := range ips {
if IsPrivateIP(ip) {
return nil, errors.New("akses ke rentang IP privat atau metadata dilarang")
}
}
return net.DialTimeout(network, net.JoinHostPort(ips[0].String(), port), 3*time.Second)
},
},
}
}
Disiplin menerapkan pemeriksaan otorisasi berbasis konteks, validasi skema input atribut, pembatasan sumber daya paginasi, dan isolasi jaringan anti-SSRF adalah kunci untuk menjaga agar API enterprise tetap kokoh dari serangan logika siber modern.
