Domain 2Web App AttacksCORE

Essential Tools Reference

Comprehensive web security tools reference covering Burp Suite, sqlmap, XSStrike, ffuf, Gobuster, Nikto, and other essential tools with installation, usage examples, and OSCP-specific workflows.

Domain: Domain 2: Web Application Penetration Testing•Updated: 2026-09-01
#Burp Suite#sqlmap#XSStrike#ffuf#Gobuster#OSCP Tools

Essential Tools Reference

Overview

This reference covers every tool you will realistically encounter during the OSCP web application modules. For each tool, we provide installation instructions, core usage patterns, advanced techniques, and OSCP-specific tips. Treat this as your quick-lookup companion during labs and the exam.


1. Burp Suite Community Edition

What It Is

Burp Suite is the single most important tool for web application testing. It acts as an intercepting proxy between your browser and the target, allowing you to inspect, modify, and replay every HTTP/S request and response. The Community (free) edition includes Proxy, Repeater, Intruder (limited), Decoder, Comparer, and Sequencer. The Professional edition adds the automated Scanner and unlimited Intruder threading.

Installation

# Download from https://portswigger.net/burp/communitydownload
# Requires Java 11+ installed
# On Kali Linux (pre-installed):
burpsuite

# Manual install:
wget https://portswigger.net/burp/releases/latest?version=community
# Follow the installer wizard

Browser Configuration

  1. Open Burp Suite → Proxy → Options → Add listener (e.g., 127.0.0.1:8080)
  2. Install the CA certificate: Proxy → Options → CA Certificate → Export → save as burp.cacert.der
  3. Convert for browser trust:
    openssl x509 -inform DER -in burp.cacert.der -out burp.cacert.pem
    sudo cp burp.cacert.pem /usr/local/share/ca-certificates/
    sudo update-ca-certificates
  4. Configure browser proxy to 127.0.0.1:8080 (or use FoxyProxy extension)

Key Modules Deep Dive

Proxy

  • Intercept On/Off: Toggle live interception. Keep OFF during normal browsing, ON when you need to catch a specific request.
  • Match and Replace: Automatically modify requests/responses on the fly (great for bypassing simple IP checks or altering headers).
  • Scope: Define your target scope under Proxy → Options → Scope. Requests outside scope are auto-forwarded.

Repeater

  • Send a captured request, modify any part (URL, headers, body), and resend. This is your primary manual exploitation workspace.
  • Tips: Use Ctrl+R to resend quickly. Right-click → Send to Repeater from the Proxy tab.
  • OSCP Tip: When testing SQLi or command injection, keep a Repeater tab open and incrementally modify payloads while watching response differences.

Intruder

Four attack types:

Type Description OSCP Use Case
Sniper Single payload position, cycles through wordlist Parameter fuzzing, single-field brute force
Battering Ram Same payload at multiple positions simultaneously Testing same injection across multiple params
Pitchfork Multiple positions, payloads advance in lockstep Multi-parameter brute force (user + password)
Cluster Bomb All combinations of multiple payload sets Credential stuffing, exhaustive brute force

OSCP Intruder Workflow for Login Brute Force:

  1. Capture a failed login POST request → Send to Intruder
  2. Clear positions → Highlight username and/or password → Add § (Ctrl+I)
  3. Payloads tab → Load rockyou.txt or custom wordlist
  4. Attacks → Start attack → Sort by “Length” or “Status” to find anomalies

Decoder

  • Encode/decode data in Base64, URL, HTML entity, MD5, SHA1, etc.
  • Chain multiple encodings (e.g., URL-encode then Base64-encode).
  • OSCP Tip: Use this to decode session cookies, encoded payloads, or obfuscated parameters.

Comparer

  • Hex or text diff of two responses. Essential for detecting subtle differences in boolean-based blind SQLi or when comparing authenticated vs. unauthenticated responses.

Sequencer

  • Analyze the entropy of session tokens to determine if they are predictable.
  • OSCP Relevance: Rarely needed directly, but understanding token randomness helps assess session hijacking feasibility.

Burp Macros and Session Handling

  • Macros: Record a sequence of requests (e.g., login) that Burp automatically replays before each Intruder request to maintain session state.
  • Session Handling Rule: Apply macros automatically so every Intruder attack runs authenticated.

OSCP-Specific Burp Tips

  1. Always set Scope: Prevents noise from non-target requests cluttering your history.
  2. Use the “Send to Repeater” shortcut liberally: Ctrl+R is your best friend during manual exploitation.
  3. Intruder is your brute-force engine: For OSCP, you will use Intruder far more than the Scanner. Practice credential attacks, parameter fuzzing, and IDOR enumeration.
  4. Keep a “cheat sheet” tab: Maintain a Repeater instance with common payloads for SQLi, XSS, LFI, and command injection so you can copy-paste quickly.
  5. Community Edition limitation: Intruder is throttled (5 requests/sec). For large wordlists, consider ffuf or hydra as alternatives.

2. sqlmap

What It Is

sqlmap is an open-source, automated SQL injection detection and exploitation tool. It supports a wide range of databases (MySQL, PostgreSQL, MSSQL, Oracle, SQLite, etc.) and injection techniques (error-based, union-based, boolean blind, time blind, stacked queries).

Installation

# Kali Linux (pre-installed)
sqlmap --version

# Manual install via Git (recommended for latest version):
git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git
cd sqlmap
python3 sqlmap.py --version

# Via pip:
pip install sqlmap

Core Usage Patterns

Detection Phase

# Basic detection (auto-detects injection point and technique)
sqlmap -u "http://target.com/page?id=1" --batch

# Test specific parameter
sqlmap -u "http://target.com/page?id=1&cat=2" -p "id" --batch

# POST data injection
sqlmap -u "http://target.com/login" --data="username=admin&password=test" --batch

# Custom HTTP headers (e.g., User-Agent injection)
sqlmap -u "http://target.com/page" --user-agent="test" --level=2 --batch

# Cookie-based injection
sqlmap -u "http://target.com/page" --cookie="session_id=abc123" --level=2 --batch

# Read request from Burp (saved as HTTP file)
sqlmap -r /path/to/request.txt --batch

Enumeration Phase

# List all databases
sqlmap -u "http://target.com/page?id=1" --dbs --batch

# List tables in a specific database
sqlmap -u "http://target.com/page?id=1" -D "target_db" --tables --batch

# List columns in a specific table
sqlmap -u "http://target.com/page?id=1" -D "target_db" -T "users" --columns --batch

# Dump all data from a table
sqlmap -u "http://target.com/page?id=1" -D "target_db" -T "users" --dump --batch

# Dump specific columns
sqlmap -u "http://target.com/page?id=1" -D "target_db" -T "users" -C "username,password" --dump --batch

Advanced Exploitation

# Get OS shell (requires advanced privileges like FILE permission or xp_cmdshell)
sqlmap -u "http://target.com/page?id=1" --os-shell --batch

# Get interactive OS shell
sqlmap -u "http://target.com/page?id=1" --os-pwn --batch

# Execute SQL statement directly
sqlmap -u "http://target.com/page?id=1" --sql-shell --batch

# Read arbitrary file from filesystem (MySQL FILE privilege)
sqlmap -u "http://target.com/page?id=1" --file-read="/etc/passwd" --batch

# Write file to server (web shell upload)
sqlmap -u "http://target.com/page?id=1" --file-write=/local/shell.php --file-dest=/var/www/html/shell.php --batch

# Use a proxy (Burp Suite)
sqlmap -u "http://target.com/page?id=1" --proxy="http://127.0.0.1:8080" --batch

# Custom injection technique
sqlmap -u "http://target.com/page?id=1" --technique=B --batch  # Boolean blind only

# Delay between requests (avoid WAF/bans)
sqlmap -u "http://target.com/page?id=1" --delay=2 --batch

# Risk level (1-3, higher = more aggressive tests)
sqlmap -u "http://target.com/page?id=1" --risk=2 --batch

sqlmap Output Locations

# Results are stored in:
~/.sqlmap/output/<target>/
├── request            # Original request
├── response           # Original response
├── dump/              # Dumped data (CSV format)
└── shell/             # Uploaded files

OSCP-Specific sqlmap Tips

  1. Always use --batch: Prevents interactive prompts that slow you down.
  2. Use --level=3 or --level=5: Higher levels test more parameters (cookies, headers, X-Forwarded-For).
  3. Combine with Burp: Use -r to import requests captured in Burp. This preserves cookies, headers, and session tokens.
  4. Be patient with time-based blind: These can take hours. Use --threads=5 to speed up, but be careful not to trigger rate limiting.
  5. --os-shell is the golden goal: On OSCP machines, if sqlmap detects an injection and the DB runs as root or has FILE privileges, you can often get a full shell.
  6. If sqlmap fails, go manual: Not all injections are sqlmap-friendly. Use Burp Repeater for manual boolean/time-based extraction.

3. XSStrike

What It Is

XSStrike is a powerful, Python-based XSS detection and exploitation tool. It features a context-aware payload generator, WAF evasion engine, and automatic parameter discovery. Unlike simple payload sprayers, XSStrike analyzes the response to understand how input is reflected and generates targeted payloads accordingly.

Installation

# Via pip
pip install xsstrike

# Via Git (latest development version)
git clone https://github.com/s0md3v/XSStrike.git
cd XSStrike
pip install -r requirements.txt
python xsstrike.py --help

Usage Examples

# Basic scan (auto-discovers parameters)
xsstrike -u "http://target.com/page?q=test"

# Target specific parameter
xsstrike -u "http://target.com/page" -p "q"

# Wildcard mode (tests all parameters including hidden ones)
xsstrike -u "http://target.com/page?q=test" --wildcard

# WAF bypass mode (generates obfuscated payloads)
xsstrike -u "http://target.com/page?q=test" --batch

# Custom payload
xsstrike -u "http://target.com/page?q=test" --payload="alert(document.domain)"

# Read request from file
xsstrike -r /path/to/request.txt

# Re-test previously found vulnerabilities
xsstrike -u "http://target.com/page?q=test" --retest

# Skip WAF check (faster, but may miss WAF-protected vulns)
xsstrike -u "http://target.com/page?q=test" --skip-waf

How XSStrike Works

  1. Parameter Discovery: Sends test payloads to identify which parameters reflect input.
  2. Context Analysis: Determines the injection context (HTML body, attribute, JavaScript, URL, etc.).
  3. Payload Generation: Generates context-specific payloads using its AST (Abstract Syntax Tree) parser.
  4. WAF Detection: Checks if a WAF is present and adapts payloads accordingly.
  5. Verification: Confirms vulnerabilities by checking for actual execution, not just reflection.

OSCP-Specific XSStrike Tips

  1. XSS on OSCP is usually about cookie theft or session hijacking: Focus on payloads that exfiltrate document.cookie to your listener.
  2. Combine with a listener: Set up a simple Python HTTP server to receive stolen cookies:
    python3 -c "import http.server; http.server.HTTPServer(('', 80), http.server.SimpleHTTPRequestHandler).serve_forever()"
  3. Stored XSS is more valuable: A single stored XSS can affect all users who visit the page. Prioritize stored over reflected.
  4. XSStrike may produce false positives: Always verify manually in the browser.

4. ffuf (Fuzz Faster U Fool)

What It Is

ffuf is an extremely fast, Go-based web fuzzer. It is the modern replacement for Gobuster and Dirb in many workflows. It supports multiple modes: directory/file discovery, virtual host discovery, parameter fuzzing, and parameter value fuzzing.

Installation

# Kali Linux (pre-installed)
ffuf -V

# Via Go
go install github.com/ffuf/ffuf/v2@latest

# Via package manager (Debian/Kali)
sudo apt install ffuf

# Binary download
wget https://github.com/ffuf/ffuf/releases/latest/download/ffuf_<arch>
chmod +x ffuf_<arch>
sudo mv ffuf_<arch> /usr/local/bin/ffuf

Usage Examples

# Directory/file enumeration
ffuf -u http://target.com/FUZZ -w /usr/share/wordlists/dirb/common.txt

# With extensions
ffuf -u http://target.com/FUZZ -w common.txt -e .php,.html,.bak,.txt,.zip

# Recursive directory discovery
ffuf -u http://target.com/FUZZ -w common.txt -recursion

# Virtual host discovery
ffuf -u http://target.com -w subdomains.txt -H "Host: FUZZ.target.com" -fs 1234

# POST parameter fuzzing
ffuf -u http://target.com/login -X POST -d "username=admin&password=FUZZ" -w rockyou.txt

# Header fuzzing
ffuf -u http://target.com -w headers.txt -H "X-Custom-Header: FUZZ"

# Multiple wordlists (Cluster Bomb equivalent)
ffuf -u http://target.com/FUZZ1/FUZZ2 -w dirs.txt:FUZZ1 -w files.txt:FUZZ2

# Filter by status code (show only 200 and 302)
ffuf -u http://target.com/FUZZ -w common.txt -mc 200,302

# Filter by response size (exclude default 404 pages)
ffuf -u http://target.com/FUZZ -w common.txt -fs 1234

# Rate limiting and threading
ffuf -u http://target.com/FUZZ -w common.txt -t 50 -rate 100

# JSON output for processing
ffuf -u http://target.com/FUZZ -w common.txt -of json -o results.json

Wordlist Resources

# Kali default wordlists
/usr/share/wordlists/dirb/common.txt
/usr/share/wordlists/dirb/big.txt
/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt
/usr/share/wordlists/seclists/Discovery/Web-Content/

# Recommended custom wordlists
# SecLists (comprehensive)
git clone --depth 1 https://github.com/danielmiessler/SecLists.git

OSCP-Specific ffuf Tips

  1. Start small, go big: Begin with common.txt (~2000 entries), then escalate to big.txt or SecLists if needed.
  2. Use -fs (filter size): The most effective filter. Most 404 pages have a consistent size — filter them out to see only interesting responses.
  3. Add extensions with -e: Many OSCP machines use .php files. Always fuzz with common extensions.
  4. Combine with recursion: -recursion will fuzz discovered directories too, revealing deeper paths.
  5. ffuf is faster than Gobuster: For time-constrained exam scenarios, ffuf is your best enumeration tool.

5. Gobuster

What It Is

Gobuster is a Go-based tool for brute-forcing URIs (directories and files) and DNS subdomains. While ffuf has largely superseded it in flexibility, Gobuster remains popular and is pre-installed on Kali.

Installation

# Kali Linux (pre-installed)
gobuster version

# Via Go
go install github.com/OJ/gobuster/v3@latest

# Binary
wget https://github.com/OJ/gobuster/releases/latest/download/gobuster-linux-amd64
chmod +x gobuster-linux-amd64
sudo mv gobuster-linux-amd64 /usr/local/bin/gobuster

Usage Examples

# Directory brute-forcing
gobuster dir -u http://target.com -w /usr/share/wordlists/dirb/common.txt

# With extensions
gobuster dir -u http://target.com -w common.txt -x php,html,bak,txt,zip

# With thread count
gobuster dir -u http://target.com -w common.txt -t 50

# Filter by status code
gobuster dir -u http://target.com -w common.txt -s 200,301,302,403

# Skip status codes (hide 404s)
gobuster dir -u http://target.com -w common.txt -k 404

# Subdomain enumeration
gobuster dns -d target.com -w subdomains.txt

# Globbing mode (pattern matching)
gobuster dir -u http://target.com -w common.txt -g "*.php"

OSCP-Specific Gobuster Tips

  1. Use -x for extensions: Critical for finding .php backdoors and config files.
  2. 403 responses are interesting: On OSCP, a 403 often means the directory exists but you lack permissions — still worth investigating.
  3. DNS mode for internal recon: After pivoting, use gobuster dns to enumerate internal subdomains.

6. Nikto

What It Is

Nikto is a comprehensive web server scanner that checks for outdated server software, dangerous files/CGIs, misconfigurations, and known vulnerabilities across 7000+ checks.

Installation

# Kali Linux (pre-installed)
nikto -Version

# Via package manager
sudo apt install nikto

# Via Git
git clone https://github.com/sullo/nikto.git
cd nikto/program
perl nikto.pl --help

Usage Examples

# Basic scan
nikto -h http://target.com

# With SSL
nikto -h https://target.com -ssl

# Specify port
nikto -h http://target.com -p 8080

# Use proxy
nikto -h http://target.com -proxy 127.0.0.1:8080

# Authenticated scan
nikto -h http://target.com -id admin:password

# Output to file
nikto -h http://target.com -o report.txt -Format txt
nikto -h http://target.com -o report.html -Format html

# Tune specific checks (1-25, 0 = all)
nikto -h http://target.com -Tuning 1ox  # Info gathering only, exclude XSS

# Evasion techniques
nikto -h http://target.com -everything

OSCP-Specific Nikto Tips

  1. Use as a quick triage tool: Run Nikto early to identify obvious misconfigurations, default pages, and outdated software.
  2. Do NOT rely on Nikto alone: It produces many false positives. Verify every finding manually.
  3. Check for default credentials: Nikto often flags default login pages — try common credentials.
  4. Time constraint: A full Nikto scan can take 10-30 minutes. Use -Tuning to focus on relevant checks during the exam.

7. wfuzz

What It Is

wfuzz is a flexible, Python-based web fuzzer that supports multiple fuzzing positions (FUZZ keyword), custom headers, POST data, and advanced filtering. It is particularly useful for parameter discovery and value fuzzing.

Installation

# Via pip
pip install wfuzz

# Kali Linux
sudo apt install wfuzz

Usage Examples

# Basic directory fuzzing
wfuzz -c -z file,/usr/share/wordlists/dirb/common.txt http://target.com/FUZZ

# POST data fuzzing
wfuzz -c -z file,rockyou.txt -d "user=admin&pass=FUZZ" http://target.com/login

# Header fuzzing
wfuzz -c -z file,headers.txt -H "X-Forwarded-For: FUZZ" http://target.com

# Multiple fuzzing positions
wfuzz -c -z file,users.txt -z file,pass.txt http://target.com/login?user=FUZZ&pass=FUZZ

# Filter by word count (exclude 404 pages)
wfuzz -c -z file,common.txt -hc 404 http://target.com/FUZZ

# Filter by content length
wfuzz -c -z file,common.txt -hl 1234 http://target.com/FUZZ

# Rate limiting
wfuzz -c -z file,common.txt --hc 404 -b 10 http://target.com/FUZZ

8. Nmap for Web Reconnaissance

What It Is

While Nmap is primarily a port scanner, its NSE (Nmap Scripting Engine) scripts make it invaluable for web application reconnaissance.

Web-Relevant Nmap Commands

# Service version detection on web ports
nmap -sV -p 80,443,8080,8443 target.com

# HTTP enumeration script
nmap --script http-enum -p 80 target.com

# HTTP title extraction
nmap --script http-title -p 80 target.com

# Detect web vulnerabilities
nmap --script http-vuln* -p 80 target.com

# Full web scan with multiple scripts
nmap -sV -sC -p 80,443,8080 --script http-enum,http-title,http-methods target.com

# Detect specific technologies
nmap --script http-php-version -p 80 target.com
nmap --script http-apache-users -p 80 target.com

Tool Selection Matrix

Attack Type Primary Tool Secondary Tools When to Use
SQL Injection sqlmap Burp Repeater, manual sqlmap for automation; manual for complex/filtered injections
XSS XSStrike Burp Suite, Dalfox, manual XSStrike for detection; manual for exploitation chains
Command Injection Burp Repeater Manual testing, commix Almost always manual on OSCP
LFI/RFI Burp Repeater ffuf, manual Manual with common path traversal payloads
XXE Burp Repeater Manual, custom payloads Manual with Burp is most reliable
SSRF Burp Repeater Manual, custom scripts Manual testing with internal IP ranges
Brute Force Burp Intruder ffuf, hydra, Medusa Intruder for web forms; hydra for protocol-level
Directory Enumeration ffuf Gobuster, Dirsearch ffuf for speed; Gobuster for simplicity
Authentication Bypass Burp Suite Manual, custom scripts Manual logic testing with Burp
Session Analysis Burp Sequencer Manual, browser dev tools Understanding token patterns
Server Recon Nikto Nmap NSE, whatweb Quick triage before deep testing
Parameter Fuzzing ffuf wfuzz, Burp Intruder Discovering hidden parameters

Quick Reference: Tool Comparison

Feature Burp Suite OWASP ZAP sqlmap ffuf Gobuster
Cost Free/Pro Free Free Free Free
Proxy Yes Yes No No No
Manual Testing Excellent Good N/A N/A N/A
Automation Pro only Yes Yes Yes Yes
Speed Moderate Moderate Varies Very Fast Fast
Learning Curve Medium Low Low Low Low
OSCP Value Critical Backup High High Medium
Extensibility BApp Store Add-ons Python scripts Limited Limited

OSCP Exam Tool Strategy

Pre-Exam Preparation

  1. Burp Suite: Master Proxy, Repeater, and Intruder. These three modules cover 90% of web testing on OSCP.
  2. sqlmap: Practice the full workflow from detection to --os-shell. Know when to fall back to manual.
  3. ffuf: Have a go-to command for directory enumeration memorized.
  4. Wordlists: Know where Kali wordlists are located. Consider carrying a USB with SecLists.

During the Exam

  1. Nmap first: Identify web services and technologies.
  2. ffuf/Gobuster second: Enumerate directories and files.
  3. Burp third: Intercept, analyze, and manually test each endpoint.
  4. sqlmap fourth: Automate SQLi exploitation when injection is confirmed.
  5. Nikto as needed: Quick scan if you’re stuck and need ideas.

Time Management

  • Reconnaissance (Nmap + ffuf): 15-30 minutes
  • Burp analysis and manual testing: 30-60 minutes per target
  • sqlmap exploitation: 15-45 minutes (can be longer for blind SQLi)
  • Rule of thumb: If a tool has not produced results in 30 minutes, switch approach or target.