> For the complete documentation index, see [llms.txt](https://dika-maulidal.gitbook.io/home/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://dika-maulidal.gitbook.io/home/offensive/bug-hunting-workflow.md).

# Bug Hunting Workflow

### Target Bug Findings

Melalui kombinasi taktik dan alur kerja di dalam dokumentasi ini, berikut adalah daftar celah keamanan (*vulnerabilities*) yang ditargetkan untuk ditemukan:

* **Injections & Server-Side**: SQL Injection (SQLi), Cross-Site Scripting (XSS), Path Traversal / LFI, Command Injection, XXE, SSRF, CRLF Injection.
* **Infrastructure & Client-Side**: Subdomain Takeover, Cloud & Server Misconfiguration, Sensitive Data Exposure (`.env`, `.git`), Open Redirect, Hidden JS API Endpoints.

### Integrated Arsenal (Tools)

Seluruh fase otomatisasi dan validasi manual di dalam *workflow* ini mengandalkan ekosistem *tools* berikut:

* Recon & Discovery: `subfinder` | `dnsx` | `httpx` | `katana` | `uro`
* Scanners & Fuzzers: `xray` | `nuclei` | `ffuf` | `gf` | `mantra`
* Visual & Validation: `gowitness` | `Burp Suite`

### Workflow Architecture

```mermaid
graph TD
    %% Define Styles
    classDef phase fill:#232733,stroke:#3b4252,stroke-width:2px,color:#eceff4;
    classDef file fill:#3b4252,stroke:#81a1c1,stroke-width:1px,color:#88c0d0;

    %% Phase 1 & 2 & 3
    P1["Phase 1: Subdomain Recon <br/><b>subfinder | dnsx | httpx</b>"]:::phase --> F1(recon/alive.txt):::file
    
    F1 --> P2["Phase 2 & 3: Crawling & Cleaning <br/><b>Katana | uro</b>"]:::phase
    P2 --> F3(recon/clean-urls.txt):::file

    %% Segregation (Phase 3.1)
    F3 --> P31["Phase 3.1: Advanced Noise Filtering <br/><b>grep Filter</b>"]:::phase
    P31 --> F4(recon/final-js.txt):::file
    P31 --> F5(recon/final-no-js.txt):::file

    %% Parallel Pipelines
    %% Path 1: JS
    F4 --> P7["Phase 7: JS & API Hunting <br/><b>SecretFinder</b>"]:::phase
    P7 --> F6(recon/secrets/js_secrets.txt):::file

    %% Path 2: Root Subdomain
    F1 --> P6["Phase 6: Targeted Scanning <br/><b>Nuclei Cloud/Takeover</b>"]:::phase
    P6 --> F7(recon/nuclei/):::file

    F1 --> P8["Phase 8: Directory Fuzzing <br/><b>ffuf | Xray dirscan</b>"]:::phase
    P8 --> F8(recon/fuzzing/):::file

    F1 --> P9["Phase 9: Visual Recon <br/><b>gowitness</b>"]:::phase
    P9 --> F9(recon/screenshots/):::file

    %% Path 3: Parameters
    F5 --> P4["Phase 4 & 5: Param Filter & Deep Scan <br/><b>gf | Xray Injection</b>"]:::phase
    P4 --> F11(recon/xray/):::file

    %% Final Stage
    F6 & F7 & F8 & F9 & F11 --> P10["Phase 10: Manual Validation <br/><b>Burp Suite Integration</b>"]:::phase
```

### Phase 1: Subdomain Enumeration & Validation

Proses ini bertujuan untuk mengumpulkan subdomain, memvalidasi catatan DNS, dan memastikan web server aktif (HTTP/HTTPS) sebelum dilakukan proses *crawling* menggunakan Katana.

```bash
subfinder -d target.com -silent | \
dnsx -silent | \
httpx -silent -follow-redirects -o recon/alive.txt
```

**Penjelasan Flag:**

* `subfinder -d` : Mencari subdomain secara pasif dari berbagai sumber.
* `dnsx -silent` : Memvalidasi apakah subdomain memiliki catatan DNS yang valid (membuang domain mati).
* `httpx -follow-redirects` : Memeriksa protokol HTTP/HTTPS yang aktif dan mengikuti *redirect* untuk mendapatkan URL akhir yang valid.
* `-o recon/alive.txt` : Menyimpan *output* berupa list URL bersih. Flag seperti `-status-code` atau `-tech-detect` sengaja dihilangkan agar *output* file ini bisa langsung dikonsumsi oleh Katana tanpa menyebabkan eror *parsing*.

### Phase 2: Crawling & URL Discovery

Setelah mendapatkan daftar URL yang aktif dari fase sebelumnya (`recon/alive.txt`), langkah selanjutnya adalah melakukan *web crawling* dan *spidering*. Proses ini bertujuan untuk memetakan seluruh endpoint, parameter, dan aset tersembunyi yang ada pada target menggunakan Katana.

```bash
katana -list recon/alive.txt \
-fs fqdn \
-jc \
-kf all \
-ef png,jpg,jpeg,gif,svg,woff,woff2,css \
-silent \
-o recon/urls.txt
```

**Penjelasan Flags & Optimalisasi**

* `-list recon/alive.txt`

  Menggunakan file hasil dari fase `httpx` sebelumnya sebagai input target. Katana akan melakukan crawling pada seluruh URL yang ada di dalam list ini.
* `-fs fqdn` *(Filter Scope)*

  Membatasi proses crawling agar hanya mengambil URL yang masih dalam satu scope *Fully Qualified Domain Name* (FQDN) dari target. Ini mencegah Katana merayap keluar ke situs pihak ketiga (seperti link Google, Facebook, dll).
* `-jc` *(JS Crawling)*

  Mengaktifkan parsing file JavaScript. Katana akan membaca file `.js` untuk menemukan endpoint atau *path* tersembunyi yang di-*hardcode* di dalam kode script.
* `-kf all` *(Known Files)*

  Memerintahkan Katana untuk otomatis memeriksa file-file standar yang umum diketahui seperti `/robots.txt`, `/sitemap.xml`, dan `/.well-known/`.
* `-ef ...` *(Extension Filter)*

  Mengabaikan ekstensi file statis (gambar, font, CSS). Hal ini sangat penting untuk menghemat waktu, mengurangi ukuran file output, dan membuat hasil scan fokus pada endpoint yang memiliki potensi celah keamanan (seperti `.php`, `.aspx`, atau parameter API).
* `-o recon/urls.txt`

  Menyimpan seluruh hasil endpoint dan URL yang ditemukan ke dalam file teks baru untuk digunakan pada fase berikutnya (misalnya *vulnerability scanning* atau *fuzzing*).

### Phase 3: URL Cleaning & Segregation

Hasil *crawling* dari Katana (`recon/urls.txt`) biasanya masih sangat kotor dan penuh dengan duplikasi. Pada fase ini, kita akan menggunakan `uro` untuk mengoptimalkan daftar URL tersebut, kemudian memisahkannya menjadi dua kategori utama: Jalur JS (untuk analisis *secret/API*) and Jalur No-JS (untuk analisis *endpoint/fuzzing*).

```bash
# 1. Bersihkan seluruh URL duplikat menggunakan uro
cat recon/urls.txt | uro > recon/clean-urls.txt

# 2. JS FILTERING (Khusus untuk mengumpulkan file JavaScript)
cat recon/clean-urls.txt | grep -E "\.js(\?|$)" > recon/js-urls.txt

# 3. NO-JS FILTERING (Mengambil semua URL selain file JavaScript)
cat recon/clean-urls.txt | grep -v -E "\.js(\?|$)" > recon/no-js-urls.txt
```

**Penjelasan Alur**

* `uro` (URL Optimization)

  Berfungsi untuk membuang *noise* dan mereduksi URL yang memiliki struktur atau parameter yang sama agar proses analisis berikutnya menjadi lebih ringan dan efisien.
* JS Path (`recon/js-urls.txt`)

  File ini berisi daftar seluruh file JavaScript yang ditemukan pada target. Jalur ini disiapkan khusus untuk fase berikutnya menggunakan tools seperti SecretFinder untuk berburu komponen sensitif (*hidden API, token, credentials*).
* No-JS Path (`recon/no-js-urls.txt`)

  File ini berisi seluruh URL bersih target minus file `.js`. Jalur ini nantinya siap diolah kembali untuk mencari parameter-parameter potensial sebelum masuk ke tahap pengujian *vulnerability* (XSS, SQLi, SSRF, dll).

#### Phase 3.1: Advanced Noise Filtering (Crucial Step)

Meskipun sudah menggunakan `uro`, hasil ekstraksi biasanya masih mengandung *out-of-scope domain* (seperti Google, Facebook analytics) dan file statis pihak ketiga. Kita harus menyaringnya secara ketat agar fuzzer kita nanti hanya bekerja pada target yang valid.

**1. Filtering Jalur No-JS (Fuzzing & Endpoint Target)**

Untuk file `no-js-urls.txt`, kita akan membuang seluruh aset statis, domain pihak ketiga, *path* bawaan WordPress yang tidak potensial, serta parameter *tracking* (UTM)

```bash
cat recon/no-js-urls.txt | \
grep -Eiv '\.(css|js|jpg|jpeg|png|gif|svg|woff|woff2|ttf|eot|ico|pdf|mp4|mp3|zip|rar|7z)(\?|$)' | \
grep -Eiv '(google|gstatic|doubleclick|facebook|twitter|instagram|linkedin|analytics|yandex|adobe)' | \
grep -Eiv '(/wp-json/|/feed/|oembed|xmlrpc|wp-login|wp-admin)' | \
grep -Eiv '(utm_|fbclid|gclid|replytocom)' > recon/final-no-js.txt
```

**2. Filtering Jalur JS (Saran Filter untuk SecretFinder)**

Untuk file `js-urls.txt`, kita TIDAK BOLEH membuang ekstensi `.js`. Namun, kita harus membuang *library* JavaScript pihak ketiga yang sudah pasti aman (seperti jQuery, React core, Angular core, Google Analytics) karena SecretFinder sering kali menghasilkan *false positive* (disangka nemu *secret token*, padahal cuma kode bawaan jQuery).

```bash
cat recon/js-urls.txt | \
grep -Eiv '(google|gstatic|facebook|twitter|instagram|linkedin|analytics|recaptcha|doubleclick)' | \
grep -Eiv '(jquery|bootstrap|react|vue|angular|wp-embed|wp-poly|lodash|moment|chunk|vendors)' > recon/final-js.txt
```

{% hint style="warning" %}
Jika fase pembersihan *noise* ini dilewati, tools pihak ketiga (seperti SecretFinder atau fuzzer parameter) akan membuang-buang *resource* VPS dan *bandwidth* untuk memindai domain eksternal (seperti Google Analytics, Facebook API, dll). Hal ini berisiko memicu WAF (*Firewall*) target untuk memblokir IP server kamu lebih cepat.
{% endhint %}

### Phase 4: Parameter Filtering for Xray Scanner

Sebelum mengumpankan URL ke Xray Vulnerability Scanner, kita perlu mengklasifikasikan URL berdasarkan jenis parameternya menggunakan `gf` (Gf-Patterns) dan `grep`. Dengan memisahkan URL sesuai potensinya (XSS, SQLi, SSRF, dll), proses *scanning* menggunakan Xray akan menjadi jauh lebih cepat, efisien, dan meminimalisir *rate-limit* dari *firewall* target.

```bash
# Buat folder khusus untuk menampung parameter
mkdir -p recon/parameters

# 1. Filter Parameter Potensial XSS
cat recon/final-no-js.txt | gf xss > recon/parameters/xss.txt 

# 2. Filter Parameter Potensial SQL Injection (SQLi)
cat recon/final-no-js.txt | gf sqli > recon/parameters/sqli.txt

# 3. Filter Parameter Potensial SSRF
cat recon/final-no-js.txt | gf ssrf > recon/parameters/ssrf.txt

# 4. Filter Parameter Potensial Local File Inclusion (LFI)
cat recon/final-no-js.txt | gf lfi > recon/parameters/lfi.txt

# 5. Filter Parameter Potensial Open Redirect
cat recon/final-no-js.txt | gf redirect > recon/parameters/redirect.txt

# 6. Filter Parameter Potensial File Upload Vulnerability
cat recon/final-no-js.txt | grep -Ei "upload|file|image|avatar|doc|pdf" > recon/parameters/upload.txt

# 7. Mengumpulkan Seluruh URL yang Memiliki Parameter (Full Parameters)
cat recon/final-no-js.txt | grep -E '\?.+=' > recon/parameters/all-parameters.txt
```

**Penjelasan Strategi**&#x20;

* Mengapa Menggunakan `gf`? `gf` secara otomatis mencari struktur *query parameter* yang biasanya rentan. Misalnya, `gf ssrf` akan mencari parameter seperti `?url=`, `?dest=`, `?path=`, dsb.
* File Upload Grep (`upload|file|image`) Karena belum ada pola bawaan `gf` yang standar untuk *file upload*, penggunaan `grep -Ei` pada nama parameter seperti `?avatar=` atau `?file=` sangat efektif untuk memetakan endpoint yang menerima input berkas.
* Full Parameter Filtering (`grep -E '\?.+='`) *Regex* ini berfungsi untuk memastikan bahwa kita memiliki satu file master (`all-parameters.txt`) yang hanya berisi URL dengan tanda tanya (`?`) dan tanda sama dengan (`=`). File ini sangat berguna jika kamu ingin melakukan *general scan* menggunakan Xray untuk seluruh modul sekaligus.

### Phase 5: Xray Deep Scan

Setelah mengklasifikasikan URL berdasarkan potensinya di Phase 4, kita sekarang masuk ke tahap eksekusi menggunakan Xray Vulnerability Scanner. Menjalankan Xray dengan menargetkan modul (*plugins*) yang spesifik sesuai dengan jenis parameternya akan membuat proses *scanning* jauh lebih cepat, akurat, dan menghemat *resource*.

```bash
# Buat folder khusus untuk menyimpan hasil scan Xray
mkdir -p recon/xray

# 1. Deep Scan - SQL Injection (SQLi)
xray webscan --url-file recon/parameters/sqli.txt --plugins sqldet --output recon/xray/sqli_results.html

# 2. Deep Scan - Cross-Site Scripting (XSS)
xray webscan --url-file recon/parameters/xss.txt --plugins xss --output recon/xray/xss_results.html

# 3. Deep Scan - Server-Side Request Forgery (SSRF)
xray webscan --url-file recon/parameters/ssrf.txt --plugins ssrf --output recon/xray/ssrf_results.html

# 4. Deep Scan - Local File Inclusion (LFI) & Path Traversal
xray webscan --url-file recon/parameters/lfi.txt --plugins path-traversal --output recon/xray/lfi_results.html

# 5. Deep Scan - Open Redirect
xray webscan --url-file recon/parameters/redirect.txt --plugins redirect --output recon/xray/redirect_results.html

# 6. Deep Scan - File Upload Vulnerability
xray webscan --url-file recon/parameters/upload.txt --plugins upload --output recon/xray/upload_results.txt

# 7. General Full Scan (Opsional - Scan semua parameter dengan seluruh modul Xray)
xray webscan --url-file recon/parameters/all-parameters.txt --output recon/xray/full_scan_results.html
```

#### Penjelasan Manajemen Plugins Xray

Menggunakan *flag* `--plugins` adalah taktik terbaik untuk menghindari deteksi *firewall* (WAF) yang agresif karena Xray hanya akan mengirimkan *payload* yang relevan.

* `--plugins sqldet`: Hanya mengaktifkan modul pendeteksi SQL Injection. Sangat efektif dipasangkan dengan list parameter hasil `gf sqli`.
* `--plugins xss`: Hanya fokus menyuntikkan *payload* reflektif dan disimpan (stored) pada parameter yang rentan XSS.
* `--plugins ssrf`: Memeriksa apakah parameter target melakukan *outbound request* ke server penyerang/internal.
* `--plugins path-traversal`: Nama resmi plugin Xray untuk mendeteksi celah LFI (*Local File Inclusion*) dan *Directory Traversal*.
* `--plugins redirect`: Digunakan khusus untuk menguji celah *Open Redirect* pada parameter seperti `?next=`, `?url=`, atau `?redir=`.
* `--plugins upload`: Memeriksa kerentanan pada mekanisme pengunggahan berkas (seperti *Unrestricted File Upload* yang bisa berujung ke RCE).
* Format Output (`.html`): Xray akan menghasilkan laporan interaktif berbasis HTML yang sangat rapi di dalam folder `recon/xray/`, sehingga memudahkan kamu untuk melakukan *review* temuan atau menjadikannya lampiran laporan *bug bounty*.

### Phase 6: Targeted Nuclei Scanning (Non-Injection & Cloud)

Untuk menghindari redundansi dengan pengujian *injection* yang sudah ditangani oleh Xray pada Phase 5, kita mengonfigurasi Nuclei secara spesifik. Nuclei akan difokuskan hanya untuk mendeteksi celah *Subdomain Takeover, Misconfiguration, Sensitive Data Exposure* (`.git`, `.env`), serta aset Cloud Storage yang terekspos.

```bash
# Buat folder output khusus Nuclei
mkdir -p recon/nuclei

# 1. Scan Takeover, Default Login, Exposure & Misconfiguration
nuclei -l recon/alive.txt -t http/takeovers/ -t http/default-logins/ -t http/exposures/ -t http/misconfiguration/ -t http/miscellaneous/ -silent -o recon/nuclei/infrastructure_exposure.txt

# 2. Scan Cloud Infrastructure & Exposed Panels
nuclei -l recon/alive.txt -t cloud/ -t http/exposed-panels/ -silent -o recon/nuclei/cloud_panels.txt
```

{% hint style="info" %}
Jika target memiliki ratusan subdomain aktif, file hasil *output* Nuclei berisiko dipenuhi oleh informasi tingkat *Low* atau *Info* yang kurang berdampak. Kamu bisa menambahkan flag `-severity medium,high,critical` di akhir *command* untuk memprioritaskan temuan yang memiliki bobot nilai *bug* atau validitas dampak yang nyata.
{% endhint %}

#### Penjelasan  Modul&#x20;

Dengan membatasi *template* menggunakan direktori spesifik, Nuclei akan berjalan sangat cepat dan tidak akan mengirimkan *payload injection* yang tidak perlu.

* `-t takeovers/`: Mencari *dangling DNS* pada subdomain aktif yang mengarah ke layanan pihak ketiga (seperti GitHub Pages, AWS S3, Heroku) namun layanannya sudah dihapus, sehingga rentan diambil alih.
* `-t cloud/`: Modul krusial untuk mendeteksi miskonfigurasi pada infrastruktur *cloud*. Nuclei akan memeriksa apakah ada *bucket* AWS S3, Google Cloud Storage, atau Azure Blob yang terekspos ke publik dan bisa diakses atau ditulis (*read/write*) secara ilegal.
* `-t exposures/,misconfiguration/`: Fokus memburu kelalaian *deployment* seperti file `.env` yang bocor, folder `/.git/` yang lupa dihapus, file cadangan database (`.sql`, `.bak`), atau konfigurasi server (Nginx/Apache) yang tidak aman.

### Phase 7: JS & API Artifact Hunting (mantra)

```bash
# Buat folder untuk menampung hasil temuan rahasia
mkdir -p recon/secrets

# Jalankan SecretFinder secara massal menggunakan xargs
cat final-js.txt | mantra
```

#### Penjelasan Teknik Eksekusi & Otomatisasi

* `cat recon/final-js.txt` Menggunakan daftar URL JavaScript target yang sudah bersih dari *library* umum (seperti jQuery atau Bootstrap) agar proses pencarian fokus dan minim *false positive*.
* `xargs -I %` Mengambil setiap baris URL dari file teks dan memasukkannya ke dalam simbol `%` sebagai argumen untuk dijalankan oleh SecretFinder secara berurutan.
* `python3 SecretFinder.py -i % -o cli` Menjalankan SecretFinder dengan input (`-i`) URL JavaScript saat ini dan menampilkan hasilnya langsung ke format CLI (*Command Line Interface*).
* `| tee recon/secrets/js_secrets.txt` *Utility* ini sangat penting untuk GitBook kamu. `tee` berfungsi ganda: tetap menampilkan proses pencarian *real-time* di layar terminal kamu, sekaligus menyimpan seluruh hasilnya ke dalam file `js_secrets.txt` agar tidak hilang saat terminal ditutup.

### Phase 8: Directory & File Fuzzing

Fase ini bertujuan untuk menemukan direktori, file, atau *hidden paths* yang tidak terindeks oleh *crawler* (seperti `/backup.zip`, `/.git`, `/config.php`, atau panel admin tersembunyi). Kita menggunakan file `recon/alive.txt` dari Phase 1 sebagai baseline target agar proses *fuzzing* tepat sasaran pada *root* masing-masing domain/subdomain.

#### 1. Mass Fuzzing Menggunakan ffuf

Kita akan mengumpankan daftar subdomain aktif ke ffuf untuk mengetes *wordlist* langsung di belakang *root domain* (contoh: `https://sub.target.com/FUZZ`).

```bash
# Buat folder output khusus fuzzing
mkdir -p recon/fuzzing

# Menjalankan ffuf secara massal pada root subdomain aktif
ffuf -w /path/to/wordlist.txt:FUZZ \
-w recon/alive.txt:TARGET \
-u TARGET/FUZZ \
-mc 200,204,301,302,307,403 \
-o recon/fuzzing/ffuf_results.json -of json
```

#### 2. Directory Scanning Menggunakan Xray

Sama halnya dengan ffuf, kita juga menggunakan `recon/alive.txt` agar modul `dirscan` milik Xray memindai kerentanan struktur direktori bawaan langsung dari akar domainnya.

```bash
# Menjalankan Xray dirscan pada root target
xray webscan --url-file recon/alive.txt --plugins dirscan --output recon/fuzzing/xray_dirscan.html
```

{% hint style="warning" %}
Karena menggunakan teknik *Multi-Wordlist (Cluster Bomb)*, jumlah total *request* yang dikirimkan adalah \[Jumlah Subdomain] x \[Jumlah Baris Wordlist]. Gunakan ukuran *wordlist* direktori yang ringkas dan efektif (misal: *top-directories* rahasia), serta pertimbangkan menambahkan flag `-rate 20` atau `-t 10` jika target memiliki proteksi *rate-limiting* yang ketat.
{% endhint %}

### Phase 9: Visual Recon (Mass Screenshots)

Setelah memetakan direktori dan melakukan *deep scan*, fase terakhir dari rangkaian *reconnaissance* ini adalah Visual Recon. Dengan mengambil tangkapan layar (*screenshot*) dari seluruh subdomain yang aktif secara otomatis menggunakan gowitness, kita dapat mengidentifikasi panel admin tersembunyi, halaman web yang tidak terurus, atau *dashboard* internal yang terekspos secara visual dengan cepat.

```bash
# Buat folder khusus untuk menyimpan hasil screenshot
mkdir -p recon/screenshots

# Jalankan gowitness untuk mengambil screenshot secara massal
gowitness file -f recon/alive.txt --screenshot-path recon/screenshots/
```

### Phase 10: Manual Validation & Proxy Integration

Fase terakhir dan paling krusial adalah Manual Validation. Semua hasil temuan otomatis dari Phase 5 hingga Phase 9 harus divalidasi secara manual untuk memastikan dampak risikonya dan menyingkirkan *false positive*. Di fase ini, kita akan mengintegrasikan Burp Suite sebagai pusat kontrol bersama Xray dan Nuclei.

#### 1. Xray Reverse & Passive Listen Mode (Burp Suite Integration)

Daripada menjalankan Xray secara terpisah, kamu bisa menjadikan Xray sebagai *upstream proxy* untuk Burp Suite. Jadi, setiap kali kamu melakukan *browsing* manual di Burp Suite, Xray akan otomatis ikut menganalisis trafik tersebut di latar belakang secara pasif (*passive scan*).

**Langkah Konfigurasi:**

1. Jalankan Xray dalam mode *listener* pasif pada port tertentu (misal: `7777`):

   Bash

   ```bash
   xray webscan --listen 127.0.0.1:7777 --output recon/xray/passive_results.html
   ```
2. Buka Burp Suite, lalu masuk ke menu Settings $$→$$ Network $$→$$ Upstream Proxy Servers.
3. Tambahkan konfigurasi baru:
   * Destination host: `*` (artinya semua *traffic* target)
   * Proxy host: `127.0.0.1`
   * Proxy port: `7777`

Sekarang, setiap *request* yang kamu kirimkan dari Burp Suite (baik dari Browser bawaan maupun menu Repeater) akan otomatis di-fuzzing oleh mesin cerdas Xray tanpa mengganggu aktivitas manualmu.

#### 2. Nuclei Interactive Verification via Burp Proxy

Jika kamu menemukan kerentanan menarik dari hasil pemindaian masal Nuclei di Phase 6, namun ingin melihat bagaimana struktur *request* dan *response*-nya secara detail di dalam Burp Suite Repeater, kamu bisa menembakkan ulang template Nuclei tersebut melewati proxy Burp.

Gunakan flag `-proxy` atau `-p` pada Nuclei:

```bash
# Menembakkan ulang template spesifik agar traffic-nya masuk ke Burp Suite (Port 8080)
nuclei -t exposures/env-file.yaml -l recon/alive.txt -proxy http://127.0.0.1:8080
```

Dengan cara ini, *request* mentah dari Nuclei akan muncul di HTTP History Burp Suite kamu, sehingga kamu bisa langsung klik kanan $$→$$ *Send to Repeater* untuk analisis manual lebih lanjut.

{% hint style="danger" %}
Celah keamanan berbasis logika bisnis (seperti *IDOR, Privilege Escalation*, atau *Broken Authentication*) tidak akan pernah bisa ditemukan secara akurat oleh *automated tools* seperti Xray atau Nuclei. Gunakan data yang telah dikumpulkan di fase-fase awal sebagai peta, lalu lakukan eksplorasi manual secara mendalam menggunakan Burp Suite Repeater/Intruder.
{% endhint %}