Audit Keamanan API: Mitigasi OWASP API Security Top 10 pada Backend Node.js & Go

Menutup celah logika bisnis yang lolos dari WAF: mitigasi Broken Object Level Authorization (BOLA), pencegahan Mass Assignment via schema validation, pembatasan paginasi defensif, dan proteksi SSRF.

PuluhLabs Security Team, Senior Application Security Specialist · 16 November 2026 · 7 min baca

Audit Keamanan API: Mitigasi OWASP API Security Top 10 pada Backend Node.js & Go
Keamanan Siber
OWASP SAFE

Isi artikel ini

  • 1. API1:2023 Broken Object Level Authorization (BOLA / IDOR)
  • 2. API3:2023 Broken Object Property Level Authorization (Mass Assignment)
  • 3. API4:2023 Unrestricted Resource Consumption
  • 4. API7:2023 Server-Side Request Forgery (SSRF)

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.

text
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): #

typescript
// 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:

typescript
// 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):

typescript
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=10000000 yang menyebabkan memori RAM server meledak.
  • Mengirimkan operasi komputasi berat tanpa batas frekuensi.

Mitigasi Paginasi dan Rate Limiting: #

  1. Tetapkan batas atas mutlak (hard cap) pada parameter paginasi (misal maksimal 100 entri per halaman).
  2. Terapkan sliding window rate limiter di tingkat API Gateway atau middleware:
typescript
// 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:

go
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.

Bagikan Artikel Ini:
Topik Terkait:Semua artikel: Keamanan aplikasi dan dataKeamanan APIOWASP API Top 10BOLA / IDORSSRF DefenseNode.js & Go
Istilah Teknis Terkait (Knowledge Graph Glossary)
Jejaring Entitas & Solusi Teknis Terkait
3 Solusi Terintegrasi
Compliance Tool

Diagnostik Kepatuhan UU PDP No. 27/2022

Audit kesiapan arsitektur web Anda terhadap regulasi perlindungan data pribadi nasional.

Buka Solusi
Legal Template

Generator Matriks ROPA Data Pribadi

Susun Record of Processing Activities (ROPA) resmi untuk kepatuhan audit korporat.

Buka Solusi
Compliance Hub

Panduan Regulasi Siber & Privasi

Rangkuman pasal krusial, sanksi denda 2% omset, dan protokol insiden 72 jam.

Buka Solusi

PuluhLabs Security Team

Senior Application Security Specialist

Terakhir diperbarui: 16 November 2026

Ingin Menerapkan Standar Performa Ini pada Proyek Agensi Anda?

Tim PuluhLabs siap menjadi mitra rekayasa digital rahasia (white-label) untuk agensi Anda. Garansi performa skor Lighthouse 90+, Core Web Vitals hijau, dan 100% hak milik kode.

Konsultasi Proyek Bersama Tim PuluhLabs

Artikel Rekomendasi Selanjutnya

Lihat Semua
  1. Keamanan Siber

    Keamanan Supply Chain Software: Menerapkan SBOM, Sigstore, dan Vulnerability Scanning di CI/CD

  2. Keamanan Siber

    Keamanan Autentikasi Modern: Mengapa HttpOnly Secure Cookie Mengungguli JWT di LocalStorage

  3. Keamanan Siber

    Arsitektur Otorisasi Enterprise: Perbandingan Role-Based (RBAC) dan Attribute-Based Access Control (ABAC)