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
- Open Burp Suite → Proxy → Options → Add listener (e.g.,
127.0.0.1:8080) - Install the CA certificate: Proxy → Options → CA Certificate → Export → save as
burp.cacert.der - 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 - 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+Rto 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:
- Capture a failed login POST request → Send to Intruder
- Clear positions → Highlight username and/or password → Add § (
Ctrl+I) - Payloads tab → Load
rockyou.txtor custom wordlist - 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
- Always set Scope: Prevents noise from non-target requests cluttering your history.
- Use the “Send to Repeater” shortcut liberally:
Ctrl+Ris your best friend during manual exploitation. - 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.
- 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.
- 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
- Always use
--batch: Prevents interactive prompts that slow you down. - Use
--level=3or--level=5: Higher levels test more parameters (cookies, headers, X-Forwarded-For). - Combine with Burp: Use
-rto import requests captured in Burp. This preserves cookies, headers, and session tokens. - Be patient with time-based blind: These can take hours. Use
--threads=5to speed up, but be careful not to trigger rate limiting. --os-shellis 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.- 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
- Parameter Discovery: Sends test payloads to identify which parameters reflect input.
- Context Analysis: Determines the injection context (HTML body, attribute, JavaScript, URL, etc.).
- Payload Generation: Generates context-specific payloads using its AST (Abstract Syntax Tree) parser.
- WAF Detection: Checks if a WAF is present and adapts payloads accordingly.
- Verification: Confirms vulnerabilities by checking for actual execution, not just reflection.
OSCP-Specific XSStrike Tips
- XSS on OSCP is usually about cookie theft or session hijacking: Focus on payloads that exfiltrate
document.cookieto your listener. - 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()" - Stored XSS is more valuable: A single stored XSS can affect all users who visit the page. Prioritize stored over reflected.
- 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
- Start small, go big: Begin with
common.txt(~2000 entries), then escalate tobig.txtor SecLists if needed. - Use
-fs(filter size): The most effective filter. Most 404 pages have a consistent size — filter them out to see only interesting responses. - Add extensions with
-e: Many OSCP machines use.phpfiles. Always fuzz with common extensions. - Combine with recursion:
-recursionwill fuzz discovered directories too, revealing deeper paths. - 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
- Use
-xfor extensions: Critical for finding.phpbackdoors and config files. - 403 responses are interesting: On OSCP, a 403 often means the directory exists but you lack permissions — still worth investigating.
- DNS mode for internal recon: After pivoting, use
gobuster dnsto 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
- Use as a quick triage tool: Run Nikto early to identify obvious misconfigurations, default pages, and outdated software.
- Do NOT rely on Nikto alone: It produces many false positives. Verify every finding manually.
- Check for default credentials: Nikto often flags default login pages — try common credentials.
- Time constraint: A full Nikto scan can take 10-30 minutes. Use
-Tuningto 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
- Burp Suite: Master Proxy, Repeater, and Intruder. These three modules cover 90% of web testing on OSCP.
- sqlmap: Practice the full workflow from detection to
--os-shell. Know when to fall back to manual. - ffuf: Have a go-to command for directory enumeration memorized.
- Wordlists: Know where Kali wordlists are located. Consider carrying a USB with SecLists.
During the Exam
- Nmap first: Identify web services and technologies.
- ffuf/Gobuster second: Enumerate directories and files.
- Burp third: Intercept, analyze, and manually test each endpoint.
- sqlmap fourth: Automate SQLi exploitation when injection is confirmed.
- 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.