Complete Bug Bounty Recon Workflow

Step-by-Step Guide with Commands for Effective Reconnaissance

Connect with me:

Introduction

This guide provides a comprehensive reconnaissance The process of gathering information about a target system before testing workflow for bug bounty hunters and penetration testers. Follow these steps to systematically discover vulnerabilities in web applications.

At masaudsec.com, we specialize in cybersecurity, ethical hacking, and penetration testing services. Contact us for professional security assessments.

🛠️ Recon Workflow Steps

1

Subdomain Enumeration

Use multiple tools to passively collect subdomains. More tools = better coverage.
subfinder -d crunch.co.uk -o subfinder.txt
assetfinder --subs-only crunch.co.uk | tee assetfinder.txt
findomain -t crunch.co.uk -q | tee find-domain.txt

🔍 What it does: These tools collect subdomains by querying different sources like crt.sh, threat intel feeds, and APIs.

🎯 Output: Multiple text files containing discovered subdomains.

2

Merge and De-duplicate

Combine all subdomains and remove duplicates to form a master list.
cat *.txt > all.txt && sort -u all.txt -o all.txt

🔍 Why? Eliminates duplicate entries from different tools for cleaner results.

🎯 Output: all.txt with unique subdomains.

3

Check for Live Subdomains

Use Httpx to see which subdomains are active and responding.
cat all.txt | httpx -l all.txt -o live_domains.txt

🔍 Why? Only active domains are worth testing further.

🎯 Output: live_domains.txt containing active subdomains.

💡 Pro Tip: Httpx can also grab versions and technologies with additional flags like -title -tech-detect -status-code

4

Collect URLs and Endpoints

Use Waymore and Katana to discover hidden or archived endpoints.
waymore -i "crunch.co.uk" -mode U -oU waymore.txt
pip install qurl
cat live_domains.txt | katana -f qurl -silent -kf all -jc -aff -d 5 -o katana-param.txt

🔍 How it works: Waymore pulls from archives while Katana performs live crawling.

🎯 Output: Two files with discovered URLs and endpoints.

Note: Katana requires live domains list while Waymore only needs the main domain.

5

Find Sensitive or Hidden Files

Look for interesting file types which may expose data.
grep -E -i -o '\S+\.(cobak|backup|swp|old|db|sql|asp|aspx|aspx~|asp~|py|py~|rb|rb~|php|php~|bak|bkp|cache|cgi|conf|csv|html|inc|jar|js|json|jsp|jsp~|lock|log|r(ar|)\.old|sql|sql\.gz|sql\.zip|sql\.tar\.gz|sql~|swp|swp~|tar|tar\.bz2|tar\.gz|txt|wadl|zip|log|xml|json|\.secret$|\.yml$|\.env$|\.config$|\.conf$|\.ini$|\.htaccess$|\.htpasswd$|\.pem$|\.key$|\.crt$|\.cer$|\.pfx$|\.p12$|\.tmp$|\.temp$|\.dump$|\.passwd$|\.shadow$|\.git$|\.svn$|\.DS_Store$|\.idea$|\.vscode$|\.bash_history$|\.zsh_history$|\.ssh$|\.id_rsa$|\.id_dsa$|\.ppk$|\.aws$|\.boto$|\.credentials$|\.token$|\.session$|\.pyc$|\.jar$|\.war$|\.class$|\.apk$|\.ipa$|\.dex$|\.plist$|\.cfg$|\.cnf$|\.properties$|\.sql.gz$|\.tar.gz$|\.backup.sql$|\.backup.gz$|\.access.log$|\.error.log)\b' "waymore.txt" "katana-param.txt" | sort -u > finding.txt

🔍 Why? These files often contain sensitive information like credentials or source code.

🎯 Output: finding.txt containing potentially sensitive file URLs.

6

Clean URLs (Remove Static Files)

Filter out unimportant file types (images, fonts, etc.).
cat waymore.txt katana-param.txt | sort -u | egrep -v '\.(css|png|blog|utm_source|utm_content|utm_campaign|utm_medium|jpeg|jpg|svg|gifs|tif|tiff|png|ttf|woff|woff2|ico|pdf|svg|txt|gif|wolf)$' > waymore-katana-unfilter-urls.txt

🔍 Why? Focus on dynamic pages that are more likely to contain vulnerabilities.

🎯 Output: waymore-katana-unfilter-urls.txt with useful endpoints only.

7

Filter Live URLs

Filter out dead URLs using Httpx again.
cat waymore-katana-unfilter-urls.txt | httpx -t 150 -rl 150 -o waymore-katana-filter-urls.txt

🔍 Why? Ensure you're only testing URLs that are accessible.

🎯 Output: waymore-katana-filter-urls.txt with alive and useful links for testing.

8

Extract Parameterized URLs

Grab URLs with parameters (=) – useful for injection testing.
grep -a = "waymore-katana-filter-urls.txt" >> parameters_with_equal.txt

🔍 Why? Parameterized URLs are ideal for testing SQLi, XSS, LFI, and other vulnerabilities.

🎯 Output: parameters_with_equal.txt containing URLs with parameters.

9

Scan with Nuclei

Use Nuclei to run automated vulnerability scans.
nuclei -l live_domains.txt -o nuclei-result.txt
nuclei -u example.com -o result.txt

🔍 How it works: Nuclei uses community templates to check for known vulnerabilities.

🎯 Output: nuclei-result.txt containing vulnerability findings.

10

Send to Burp for Manual Testing

Send all live URLs to Burp Suite using curl and Parallel.
cat waymore-katana-unfilter-urls.txt | parallel -j 10 'curl --proxy http://127.0.0.1:8080 -sk {}' >> /dev/null
cat waymore-katana-filter-urls.txt | parallel -j 10 'curl --proxy http://127.0.0.1:8080 -sk {}' >> /dev/null

🔍 Why? These URLs will appear in Burp Suite's HTTP history for manual analysis.

🎯 Result: All URLs loaded into Burp Suite for in-depth testing.

📥 Download All Commands

Get all these commands in a single script file for easy execution.

Why Automation in Bug Bounty?

Automation is crucial in bug bounty hunting for several reasons:

  • Efficiency: Automating repetitive tasks saves time and allows you to focus on analysis.
  • Scale: You can scan hundreds or thousands of targets with the same effort as scanning one.
  • Speed: Automation helps you find vulnerabilities before other hunters.
  • Documentation: Scripts serve as documentation of your methodology.

Frequently Asked Questions

What is bug bounty hunting? +

Bug bounty hunting is the process of finding and reporting vulnerabilities in software, websites, or applications in exchange for rewards. Companies run bug bounty programs to crowdsource security testing from ethical hackers.

Why is reconnaissance important in bug bounty? +

Reconnaissance is the foundation of successful bug hunting. It helps you:

  • Discover all possible attack surfaces
  • Find hidden or forgotten assets
  • Identify outdated software versions
  • Spot misconfigurations
  • Gather intelligence for targeted attacks
Good recon often leads to finding the most valuable bugs.

How long does it take to learn bug bounty? +

The learning curve varies, but typically:

  • 3-6 months: Basic understanding of web vulnerabilities
  • 6-12 months: Finding your first valid bugs
  • 1-2 years: Consistently finding high-value vulnerabilities
Continuous learning and practice are key. My free course can help you get started faster.

What tools should I start with for bug bounty? +

Start with these essential tools:

  • Browser: Chrome/Firefox with developer tools
  • Proxy: Burp Suite or OWASP ZAP
  • Scanner: Nuclei for automated vulnerability scanning
  • Crawler: Tools like Katana for endpoint discovery