Advanced Web Application Firewall (WAF) Hardening dengan ModSecurity dan Nginx

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap infrastruktur web enterprise modern, serangan siber tidak lagi sekadar iseng atau vandalisme digital, melainkan operasi terstruktur yang mengeksploitasi celah pada lapisan aplikasi (Layer 7 OSI Model). Mulai dari injeksi SQL tingkat lanjut, Cross-Site Scripting (XSS) berbasis DOM, Remote Code Execution (RCE), hingga serangan distributed Denial of Service (DDoS) lapisan aplikasi yang menyamar sebagai trafik sah.

Arsitektur web masa kini—yang mengandalkan microservices, backend berbasis Node.js/Go/PHP-FPM, penyimpanan objek S3/MinIO, serta integrasi database MySQL/MariaDB dan Redis—menciptakan permukaan serangan yang sangat luas (attack surface). Ketika seorang pengembang melakukan kesalahan kecil dalam sanitasi input (misalnya pada form login atau API endpoint GraphQL/REST), seluruh infrastruktur dapat terancam.

Secara historis, banyak organisasi mengandalkan keamanan jaringan perimeter konvensional atau menyerahkan seluruh pertahanan keamanan aplikasi ke Cloud Edge (seperti WAF Cloudflare). Meskipun CDN/Cloud WAF sangat efektif untuk mitigasi DDoS volume besar dan ancaman generik, ketergantungan mutlak pada pihak ketiga sering kali menimbulkan masalah latensi, keterbatasan kustomisasi aturan mendalam (zero-day mitigation), serta kendala kepatuhan regulasi data (data residency compliance).

Di sinilah pentingnya memiliki On-Premises / Edge Reverse Proxy WAF mandiri menggunakan Nginx yang diintegrasikan secara native dengan libmodsecurity (ModSecurity v3).

Perbandingan Kondisi: Sebelum vs Sesudah Implementasi Hardening ModSecurity

2. Konsep Inti & Deep Dive Arsitektur

ModSecurity adalah WAF open-source paling populer di dunia yang berfungsi sebagai perisai transparan untuk aplikasi web. Pada arsitektur modern berbasis Nginx (yang menggunakan event-driven architecture non-blocking), ModSecurity diintegrasikan melalui modul dinamis ngx_http_modsecurity_module yang menjembatani Nginx dengan library inti C++ (libmodsecurity atau ModSecurity v3).

Alur Eksekusi Data (Data Flow & Execution Pipeline)

Diagram ASCII berikut menunjukkan bagaimana sebuah HTTP request masuk diproses oleh Nginx dan diperiksa oleh ModSecurity sebelum diteruskan ke backend server (PHP-FPM/Node.js/Go):

[ Client / Browser ]
       │
       ▼ (HTTPS / TLS Termination)
[ Nginx Reverse Proxy ]
       │
       ├─► ModSecurity Module (libmodsecurity v3)
       │     │
       │     ├─► Phase 1: Request Headers Inspection
       │     ├─► Phase 2: Request Body Inspection (POST/PUT data)
       │     │     └─► Evaluasi OWASP Core Rule Set (CRS v3.3+)
       │     │           └─► Hitung Anomaly Score / Deteksi Payload
       │     │
       │     ├─► [ JIKA ANOMALI TERDETEKSI ] ──► Action: BLOCK (HTTP 403)
       │     └─► [ JIKA BERSIH / AMAN ]
       │
       ▼
[ Upstream Backend: PHP-FPM / Node.js / Go / Python ]
       │
       ├─► Database (MySQL/MariaDB) & Cache (Redis)
       │
       ▼
[ ModSecurity Module ]
       │     │
       │     └─► Phase 3 & 4: Response Headers & Body Inspection
       │
       ▼
[ Client / Browser (Response Terkirim) ]

5 Fase Utama Inspeksi ModSecurity

1. Phase 1 (Request Headers): Memeriksa header HTTP yang masuk (User-Agent, Host, Cookie, Authorization, Content-Type) sebelum tubuh request dibaca.
2. Phase 2 (Request Body): Memeriksa isi tubuh request (data POST, form submission, payload JSON/XML). Di sinilah sebagian besar injeksi SQL, XSS, dan deserialization attacks terdeteksi.
3. Phase 3 (Response Headers): Memeriksa header yang dikirimkan oleh backend sebelum diteruskan ke klien.
4. Phase 4 (Response Body): Memeriksa isi respons dari backend (berguna untuk mencegah Information Disclosure seperti kebocoran stack trace error atau database error message).
5. Phase 5 (Logging): Menulis log audit terperinci ke disk atau sistem pemantauan eksternal.

3. Perbandingan Komparatif / Analisis Pendekatan

Dalam membangun WAF berbasis Nginx + ModSecurity, arsitek dihadapkan pada beberapa pilihan implementasi yang memengaruhi utilisasi sumber daya (CPU, RAM, dan I/O disk).

[!TIP] Untuk arsitektur web modern berkinerja tinggi, Pendekatan 2 (ModSecurity v3 + Nginx) adalah standar emas industri karena memberikan keseimbangan sempurna antara kontrol keamanan tingkat militer dan efisiensi sumber daya server.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum melakukan kompilasi dan instalasi ModSecurity v3 beserta konektor Nginx, pastikan sistem operasi Anda (rekomendasi: Ubuntu 22.04 LTS / 24.04 LTS atau Debian 12) telah disiapkan dengan spesifikasi minimal:

• CPU: 2 Core / vCPU
• RAM: 4 GB (Kompilasi ModSecurity memori-intensif)
• Disk: 20 GB SSD

Instalasi Dependensi Sistem

Jalankan perintah berikut untuk menginstal seluruh pustaka pengembangan, compiler, dan perangkat utilitas yang diperlukan:

sudo apt update && sudo apt upgrade -y
sudo apt install -y \
    git build-essentials cmake libtool autoconf automake \
    pkg-config libcurl4-openssl-dev libgeoip-dev \
    libyajl-dev libfuzzy-dev doxygen dh-autoreconf \
    libxml2-dev libpcre2-dev zlib1g-dev libssl-dev \
    apt-transport-https lsb-release ca-certificates curl

5. Panduan Implementasi Langkah demi Langkah

Langkah 1: Kompilasi dan Instalasi Libmodsecurity (v3)

Clone repositori resmi ModSecurity dari GitHub dan lakukan kompilasi sumber:

cd /usr/src
sudo git clone --depth 1 -b v3/master --recurse-submodules https://github.com/SpiderLabs/ModSecurity.git
cd ModSecurity

sudo ./build.sh
sudo ./configure
sudo make -j$(nproc)
sudo make install

Langkah 2: Kompilasi Modul Nginx untuk ModSecurity (ngx_http_modsecurity)

Karena Nginx memerlukan modul dinamis agar dapat berkomunikasi dengan libmodsecurity, kita harus mengkompilasi modul tersebut dari sumber yang sesuai dengan versi Nginx yang akan diinstal.

# Cek versi Nginx yang akan diinstal atau gunakan versi stabil terbaru
NGINX_VERSION="1.24.0"

cd /usr/src
sudo git clone https://github.com/SpiderLabs/ModSecurity-nginx.git
wget http://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz
tar -zxvf nginx-${NGINX_VERSION}.tar.gz

cd nginx-${NGINX_VERSION}
# Konfigurasi source dengan menyertakan modul dinamis modsecurity
sudo ./configure --with-compat --add-dynamic-module=/usr/src/ModSecurity-nginx
sudo make modules

# Salin modul hasil kompilasi ke direktori modul Nginx
sudo mkdir -p /etc/nginx/modules
sudo cp objs/ngx_http_modsecurity_module.so /etc/nginx/modules/

Langkah 3: Instalasi Nginx Resmi & Konfigurasi Modul

Tambahkan repositori resmi Nginx dan instal paket utama:

curl -fsSL https://nginx.org/keys/nginx_signing.key | sudo gpg --dearmor -o /usr/share/keyrings/nginx-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/ubuntu $(lsb_release -cs) nginx" | sudo tee /etc/sudoers.d/99nginx /etc/apt/sources.list.d/nginx.list

sudo apt update
sudo apt install -y nginx=${NGINX_VERSION}-1~$(lsb_release -cs)

Langkah 4: Konfigurasi File Utama ModSecurity (modsecurity.conf)

Buat direktori konfigurasi dan unduh file konfigurasi rekomendasi serta OWASP Core Rule Set (CRS):

sudo mkdir -p /etc/nginx/modsec
cd /usr/src/ModSecurity
sudo cp modsecurity.conf-recommended /etc/nginx/modsec/modsecurity.conf
sudo cp unicode.mapping /etc/nginx/modsec/

# Unduh OWASP ModSecurity Core Rule Set (CRS)
cd /etc/nginx/modsec
sudo git clone https://github.com/coreruleset/coreruleset.git
cd coreruleset
sudo cp crs-setup.conf.example crs-setup.conf
sudo cp rules/REQUEST-900-EXCLUSION-RULES-BEFORE-CRS.conf.example rules/REQUEST-900-EXCLUSION-RULES-BEFORE-CRS.conf

Ubah mode operasional ModSecurity dari Detection Only (hanya mencatat) menjadi On (memblokir serangan):

sudo sed -i 's/SecRuleEngine DetectionOnly/SecRuleEngine On/' /etc/nginx/modsec/modsecurity.conf

Buat file utama penghubung /etc/nginx/modsec/main.conf:

# /etc/nginx/modsec/main.conf
Include /etc/nginx/modsec/modsecurity.conf
Include /etc/nginx/modsec/coreruleset/crs-setup.conf
Include /etc/nginx/modsec/coreruleset/rules/*.conf

Langkah 5: Konfigurasi Nginx untuk Mengaktifkan ModSecurity

Edit file /etc/nginx/nginx.conf untuk memuat modul dinamik ModSecurity:

user nginx;
worker_processes auto;
pid /var/run/nginx.pid;

load_module modules/ngx_http_modsecurity_module.so;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;
    error_log /var/log/nginx/error.log warn;

    sendfile on;
    keepalive_timeout 65;

    include /etc/nginx/conf.d/*.conf;
}

Buat file Virtual Host untuk aplikasi web Anda di /etc/nginx/conf.d/app.conf:

server {
    listen 80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    # Aktifkan ModSecurity pada Virtual Host ini
    modsecurity on;
    modsecurity_rules_file /etc/nginx/modsec/main.conf;

    location / {
        proxy_pass http://127.0.0.1:8080; # Mengarah ke backend (Node.js/Go/PHP-FPM)
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # Timeout tuning untuk high concurrency
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
    }

    # Lokasi penyimpanan file statis (opsional, bypass WAF untuk performa optimal jika diperlukan)
    location /static/ {
        modsecurity off; # Nonaktifkan WAF khusus file statis murni
        alias /var/www/html/static/;
        expires 30d;
    }
}

Uji konfigurasi Nginx dan restart layanan:

sudo nginx -t
sudo systemctl restart nginx
sudo systemctl enable nginx

6. Bedah Kode & Penjelasan Detail Baris Kunci

Mari kita bedah beberapa parameter krusial dalam file konfigurasi yang baru saja dibuat:

1. modsecurity on; dan modsecurity_rules_file /etc/nginx/modsec/main.conf; Baris ini mengaktifkan engine ModSecurity per blok server secara modular. Anda dapat menonaktifkannya pada virtual host tertentu yang hanya melayani aset internal tepercaya.

2. SecRuleEngine On Parameter di dalam modsecurity.conf ini menentukan status operasional:

   • Off: ModSecurity dinonaktifkan sepenuhnya.
   • DetectionOnly: ModSecurity menganalisis request, mencatat pelanggaran ke log, tetapi tidak memblokir request tersebut (sangat berguna untuk tahap staging/tuning awal agar tidak memutus trafik sah).
   • On: Mode aktif penuh. Request yang melanggar aturan akan langsung diputus dengan kode HTTP 403.

3. Include /etc/nginx/modsec/coreruleset/rules/*.conf Memuat ribuan aturan bawaan OWASP CRS v3.3+ yang mencakup perlindungan terhadap injeksi SQL, XSS, RCE, Local File Inclusion (LFI), Session Fixation, dan Protocol Violations.

7. Skenario Produksi & Studi Kasus Dunia Nyata

Studi Kasus: Menghadapi Serangan Botnet Injeksi SQL & Custom Rule Tuning

Pada lingkungan produksi skala besar (misalnya e-commerce flash sale), sering kali muncul pola serangan injeksi SQL baru yang belum tercakup secara spesifik di OWASP CRS bawaan.

Misalkan Anda mendapati log serangan pada endpoint /api/v1/products?search= yang mengirimkan payload UNION SELECT mencurigakan, namun Anda ingin membuat aturan kustom yang lebih spesifik agar tidak memicu False Positive pada pencarian teks normal pengguna.

Buat file aturan kustom baru di /etc/nginx/modsec/coreruleset/rules/REQUEST-999-CUSTOM-APPLICATION-RULES.conf:

# Custom Rule untuk mendeteksi pola SQL Injection spesifik pada parameter search
SecRule ARGS:search "@rx (?i)(union\s+select|information_schema|load_file|outfile)" \
    "id:10001,\
    phase:2,\
    block,\
    t:none,t:urlDecodeUni,t:lowercase,\
    msg:'Custom SQL Injection Attack Detected via Search Parameter',\
    logdata:'Matched Data: %{MATCHED_VAR} within %{MATCHED_VAR_NAME}',\
    severity:'CRITICAL',\
    tag:'application-attack',\
    tag:'OWASP_CRS/WEB_ATTACK/SQL_INJECTION',\
    setvar:tx.anomaly_score_pl1=+%{tx.critical_anomaly_score}"

Penjelasan aturan kustom di atas:

• id:10001: ID unik aturan kustom (rentang 10000-99999 dicadangkan untuk aturan lokal).
• phase:2: Diperiksa pada tahap Request Body / Query Parameters.
• block: Tindakan langsung (menghentikan eksekusi dan merespons dengan HTTP 403).
• t:urlDecodeUni,t:lowercase: Transformasi data (melakukan dekode URL dan mengubah teks menjadi huruf kecil terlebih dahulu untuk menghindari teknik obfuscation penyerang).
• setvar:tx.anomaly_score_pl1=+...: Mengintegrasikan pelanggaran ini ke dalam sistem Anomaly Scoring Threshold OWASP CRS.

8. Common Pitfalls, Anti-Patterns & Solusi

Dalam pengalaman mengelola infrastruktur enterprise, berikut adalah kesalahan fatal yang sering dilakukan oleh pengembang dan administrator sistem:

1. Anti-Pattern: Menjalankan SecRuleEngine On Langsung di Production Tanpa Tahap Audit

   • Dampak: Ribuan trafik sah dari pelanggan (terutama yang menggunakan karakter khusus pada form input atau ekstensi browser tertentu) akan terblokir secara masif (False Positives), mengakibatkan kerugian finansial.
   • Solusi: Selalu mulai dengan SecRuleEngine DetectionOnly selama minimal 3 hingga 7 hari. Analisis file error.log Nginx dan modsec_audit.log, lalu buat Exception Rules untuk request sah sebelum memindahkannya ke mode On.

2. Pitfalls: Mengabaikan Rotasi Log Audit ModSecurity

   • Dampak: File modsec_audit.log dapat membengkak hingga ratusan gigabyte dalam hitungan hari pada trafik tinggi, menyebabkan disk server penuh dan membuat Nginx crash.
   • Solusi: Konfigurasikan utilitas logrotate sistem secara ketat.

Contoh konfigurasi /etc/logrotate.d/modsecurity:

/var/log/modsec_audit.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 nginx nginx
    sharedscripts
    postrotate
        systemctl reload nginx > /dev/null 2>&1 || true
    endscript
}

9. Benchmark, Metrik Kinerja & Tuning Performa

Untuk memastikan WAF tidak menjadi bottleneck performa pada arsitektur web berkecepatan tinggi, lakukan pengujian beban (load testing) menggunakan tool seperti k6 atau wrk sebelum dan sesudah penerapan ModSecurity.

Skrip Pengujian k6 (load-test.js)

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
    stages: [
        { duration: '30s', target: 50 },  
        { duration: '1m', target: 200 }, 
        { duration: '30s', target: 0 },  
    ],
    thresholds: {
        http_req_duration: ['p(95)<250'], // 95% request harus selesai di bawah 250ms
        http_req_failed: ['rate<0.01'],   // Error rate harus di bawah 1%
    },
};

export default function () {
    const res = http.get('https://example.com/api/v1/products?search=test');
    check(res, {
        'status is 200': (r) => r.status === 200,
        'response time < 200ms': (r) => r.timings.duration < 200,
    });
    sleep(1);
}

Tuning Parameter Performa di modsecurity.conf

Untuk memaksimalkan throughput CPU dan memori, sesuaikan direktif berikut di file modsecurity.conf:

# Batasi ukuran data request yang diperiksa agar mencegah serangan Denial of Service (DoS) berbasis memori (Memory Exhaustion)
SecRequestBodyAccess On
SecRequestBodyLimit 13107200        # Batas 12.5 MB
SecRequestBodyNoFilesLimit 131072   # Batas 128 KB untuk body tanpa file
SecRequestBodyInMemoryLimit 131072  # Simpan di memori hingga 128 KB, selebihnya ke tmpfile

# Batasi ukuran response body yang diinspeksi
SecResponseBodyAccess On
SecResponseBodyMimeType text/html text/plain
SecResponseBodyLimit 524288          # Batas 512 KB

10. Checklist Penerapan Produksi & Kesimpulan

Gunakan checklist komprehensif berikut sebelum menyatakan infrastruktur web Anda siap rilis ke publik (Production Ready):

• Modul Nginx & Libmodsecurity telah dikompilasi menggunakan versi stabil terbaru.
• OWASP Core Rule Set (CRS v3.3+) telah diunduh dan diinklusikan dengan benar pada file konfigurasi utama.
• Mode SecRuleEngine telah diuji dalam mode DetectionOnly selama minimal 3 hari untuk membersihkan False Positives.
• Direktif pembatasan ukuran request (SecRequestBodyLimit) telah disesuaikan dengan kebutuhan fungsional aplikasi (misalnya fitur file upload).
• Skrip rotasi log (logrotate) untuk audit log ModSecurity telah aktif dan diuji.
• Aturan kustom (custom rules) telah diimplementasikan untuk melindungi endpoint spesifik aplikasi (API/GraphQL/Auth).
• Pemantauan metrik sumber daya (CPU, RAM, Latensi) via Prometheus/Grafana telah dikonfigurasi untuk memantau performa Nginx secara real-time.

Dengan mengikuti panduan komprehensif ini, Anda kini memiliki benteng pertahanan Lapisan 7 (WAF) tingkat enterprise yang tangguh, mandiri, dan sangat optimal di atas fondasi Nginx dan ModSecurity.