Bug Bounty & CTF
⚠️ Bug bounty testing must stay strictly within the program's published scope and rules. For everything else, use your own lab or authorized CTF environment.
1. What Is Bug Bounty?
A bug bounty program allows security researchers to test an organization's systems within a defined scope.
Example:
Company │ └── Bug Bounty Program │ ├── api.example.com ├── app.example.com └── *.example.com
The researcher:
Find vulnerability ↓ Validate safely ↓ Document evidence ↓ Report ↓ Company verifies ↓ Fix ↓ Possible reward
2. What Is a CTF?
CTF = Capture The Flag
A CTF is a controlled security challenge.
Usually:
Challenge ↓ Find vulnerability ↓ Exploit ↓ Find flag ↓ Submit flag ↓ Score
Example flag:
FLAG{example_test_flag}
Unlike bug bounty, the objective is often to solve a deliberately vulnerable challenge.
3. Bug Bounty vs CTF
| Bug Bounty | CTF |
|---|---|
| Real systems | Deliberately vulnerable systems |
| Real business impact | Challenge/learning objective |
| Strict scope | Defined challenge environment |
| Professional report | Usually flag submission |
| Responsible disclosure | Competition/education |
| Often unpredictable | Usually has intended path |
Both teach valuable skills, but they require different mindsets.
4. Bug Bounty Rules Come First
Before touching a target:
READ PROGRAM ↓ READ SCOPE ↓ READ OUT-OF-SCOPE ↓ READ RATE LIMITS ↓ READ PROHIBITED TESTS ↓ READ REPORTING REQUIREMENTS ↓ START TESTING
Never assume:
"It's on the company's domain, so I can test it."
Scope determines authorization.
5. Scope
Suppose a program says:
In Scope: *.example.com Out of Scope: example.com thirdparty.example.com
Then don't test everything you discover.
Create:
scope.txt
Example:
*.example.com api.example.com app.example.com
And keep out-of-scope assets separate.
6. Bug Bounty Methodology
A practical workflow:
1. Scope ↓ 2. Recon ↓ 3. Asset Discovery ↓ 4. Service Discovery ↓ 5. Technology Identification ↓ 6. Endpoint Discovery ↓ 7. Parameter Discovery ↓ 8. Authentication Testing ↓ 9. Authorization Testing ↓ 10. Vulnerability Testing ↓ 11. Validation ↓ 12. Impact Assessment ↓ 13. Report
This should look familiar because it combines your entire roadmap.
7. Asset Discovery
Suppose the scope is:
*.example.com
Your goal is to understand the authorized attack surface.
Potential assets:
api.example.com dev.example.com staging.example.com admin.example.com cdn.example.com mail.example.com
Useful tools in authorized programs/labs:
subfinder amass httpx dnsx
Example:
subfinder -d example.com -o subdomains.txt
Then:
httpx -l subdomains.txt
The purpose isn't simply collecting thousands of domains.
It's:
Identify useful attack surface.
8. Don't Become a Subdomain Collector
A common beginner mistake:
5000 subdomains ↓ "I am doing great!"
Not necessarily.
Instead:
5000 assets ↓ Resolve ↓ Filter live ↓ Identify technology ↓ Group applications ↓ Find interesting targets
Quality > quantity.
9. Technology Fingerprinting
For each interesting host:
Web Server Framework Language CMS JavaScript API Cloud provider Authentication system
Tools:
whatweb https://example.com
or:
httpx -tech-detect -u https://example.com
You want to understand:
What is running here?
10. Content Discovery
Find:
/admin /api /login /register /upload /dashboard /graphql /docs /swagger
Tools:
ffuf feroxbuster gobuster dirsearch
Example:
ffuf -u https://example.com/FUZZ \ -w wordlist.txt
Only against authorized targets.
11. JavaScript Recon
Modern applications frequently expose useful information through JavaScript.
Look for:
API endpoints Routes Feature flags Environment names Third-party services Configuration Source maps
Conceptually:
Website ↓ JavaScript ↓ Endpoints ↓ API ↓ Attack Surface
12. API Discovery
Suppose JavaScript contains:
/api/users /api/orders /api/profile /api/admin
Now create an API map:
Endpoint Method -------------------------------- /api/login POST /api/profile GET /api/profile PATCH /api/orders GET /api/orders/{id} GET /api/admin GET
Then test:
- Authentication
- Authorization
- Input validation
- Rate limiting
- Business logic
13. The Most Valuable Bug Bounty Skill: Authorization
Many researchers focus heavily on:
XSS SQLi RCE
But authorization flaws can be extremely valuable.
Think:
User A │ ├── Own resources │ └── Other user's resources?
Test:
Read Create Update Delete Admin functions
14. BOLA / IDOR Testing
Example:
GET /api/invoice/1001
Your test account owns:
1001
A second test account owns:
1002
If Account A can access:
GET /api/invoice/1002
you may have a BOLA.
The strongest proof is:
Account A ↓ Unauthorized access ↓ Account B's test resource
15. Privilege Escalation in Bug Bounty
Example:
Normal User ↓ /admin ↓ Admin functionality
Test whether the server actually checks authorization.
Don't rely on:
Hidden button
because:
Hiding a button isn't authorization.
The server must enforce the permission.
16. Authentication Testing
Test the complete authentication lifecycle:
Registration ↓ Login ↓ Session ↓ Password Change ↓ Password Reset ↓ Logout ↓ Session Expiration
Potential weaknesses include:
- Account takeover
- Weak password reset
- Session problems
- MFA flaws
- Email verification flaws
- Authentication bypass
17. Password Reset Analysis
Think about:
Request reset ↓ Receive token ↓ Validate token ↓ Set new password
Questions:
Is token unpredictable? Does it expire? Can it be reused? Is it bound to the account? Can another account be affected?
Don't attack real users. Use your own test accounts.
18. Business Logic Bugs
This is where analysis becomes extremely important.
Example:
Product price = $100 Discount = 10%
Application expects:
$90
But a workflow flaw might allow:
Discount applied twice
Result:
$80
The application may be technically functioning correctly at every individual endpoint.
The vulnerability is in the business logic.
19. Race Conditions
Suppose:
Account balance = $100
A withdrawal request is sent twice at nearly the same time.
If both requests are accepted incorrectly:
$100 ↓ -$100 ↓ -$100
The application might produce an impossible state.
This is a race condition.
For bug bounty research, race-condition testing must respect program rules and avoid causing financial or operational harm.
20. SSRF
SSRF:
Server-Side Request Forgery
Concept:
Attacker ↓ Web Server ↓ Server makes request ↓ Internal resource
Potential targets in authorized environments:
Internal services Cloud metadata Internal APIs Administrative interfaces
The important analytical question:
Can user-controlled input cause the server to make an unintended network request?
21. XSS
You already learned XSS.
Bug bounty workflow:
Input ↓ Reflection/Storage ↓ Browser ↓ JavaScript execution?
Types:
Reflected Stored DOM-based
But don't stop at:
“Payload executed.”
Determine:
Who is affected? Where does it execute? What privileges does the victim have? What realistic impact exists?
22. SQL Injection
The classic flow:
User Input ↓ SQL Query ↓ Database
Test whether input changes query behavior.
But professional bug bounty testing should prioritize:
Minimal, non-destructive proof.
Don't dump an entire production database merely because you found SQL injection.
23. Command Injection
Concept:
User Input ↓ Application ↓ Operating System Command
Potential impact:
Application access ↓ OS command execution ↓ Server compromise
Again, prove the vulnerability with the smallest safe demonstration.
24. File Upload
Analyze:
File type validation Extension validation Content validation Storage location Execution behavior Access control Filename handling
Potential problems:
Malicious file ↓ Upload ↓ Server processing ↓ Unexpected execution or data exposure
Test only with safe lab files and according to program rules.
25. Open Redirect
Example:
https://example.com/redirect?url=https://example.test
If the application redirects users to arbitrary external destinations, that may create:
- Phishing support
- Trust abuse
- OAuth-related risks in certain flows
Severity depends heavily on context.
26. CORS Analysis
CORS controls browser cross-origin access.
Look at:
Access-Control-Allow-Origin Access-Control-Allow-Credentials
Don't assume:
CORS header exists = vulnerability
Analyze:
Origin + Credentials + Sensitive response + Browser behavior
27. JWT Analysis
JSON Web Tokens often look like:
HEADER.PAYLOAD.SIGNATURE
Analyze:
Algorithm Claims Expiration Issuer Audience Signature validation Authorization logic
The important question is:
Does the server correctly validate and trust the token?
28. GraphQL Bug Bounty Testing
Map:
Query Mutation Subscription
Then investigate:
Authentication Authorization Excessive data Query complexity Introspection Resolver permissions
Example:
query { user(id: "1001") { name email } }
Again, test whether the current user is actually authorized to retrieve that object.
29. Bug Bounty Triage
Not every interesting behavior deserves a report.
Before reporting, ask:
Is it in scope? ↓ Is it reproducible? ↓ Is it a security issue? ↓ Can I explain the impact? ↓ Can I provide evidence? ↓ Is it already known? ↓ Does it violate program rules?
This prevents low-quality reports.
30. Bug Bounty Report Structure
A strong report should contain:
Title Summary Affected Asset Affected Endpoint Prerequisites Steps to Reproduce Evidence Impact Severity Remediation
Example structure:
Title: Broken Object Level Authorization in /api/orders/{id} Summary: An authenticated user can access another user's order by modifying the order ID. Affected: https://target.example/api/orders/{id} Steps: 1. Login as test account A. 2. Request order 1001. 3. Change ID to 1002. 4. Observe account B's test order. Impact: Cross-account data disclosure. Remediation: Enforce server-side ownership/authorization checks before returning the requested object.
31. What Makes a Good Report?
Bad:
“IDOR found. Please fix.”
Good:
What? Broken authorization. Where? /api/orders/{id} How? Change object identifier while authenticated as another test account. Impact? Unauthorized access to another user's order data. Evidence? Request and response included. Fix? Enforce server-side authorization for the requested object.
32. CTF Methodology 🏴
CTFs are different.
When you receive a machine:
TARGET ↓ Recon ↓ Enumeration ↓ Initial Access ↓ Privilege Escalation ↓ Flag
Don't immediately search for exploits.
Start with:
nmap -sC -sV <LAB-IP>
Then build an attack-surface map.
33. CTF Enumeration
Ask:
What ports? What services? What versions? What web applications? What directories? What users? What files? What credentials? What configuration?
Example:
22 → SSH 80 → HTTP 139 → NetBIOS 445 → SMB 3306 → MySQL
Then prioritize.
34. CTF Attack-Path Thinking
Don't think:
“Port 80 exists, therefore attack port 80.”
Think:
Port 80 ↓ Web Application ↓ Version ↓ Endpoint ↓ Input ↓ Vulnerability ↓ Initial Access
Or:
SMB ↓ Share Enumeration ↓ Interesting File ↓ Credential ↓ SSH ↓ User ↓ Privilege Escalation ↓ Root
35. CTF Notes
Keep a structured file:
target.txt IP: 10.10.10.20 Ports: 22 80 445 Web: Apache Application: XYZ Users: alice bob Interesting: /backup/ /admin/ /uploads/ Credentials: [redacted in notes] Attack Path: Web → User → PrivEsc → Root
Good notes can save hours.
36. CTF Enumeration Matrix
| Port | Service | Version | Interesting? | Next Action |
|---|---|---|---|---|
| 22 | SSH | OpenSSH | Yes | Credentials |
| 80 | HTTP | Apache | High | Web enum |
| 445 | SMB | Samba | High | Share enum |
| 3306 | MySQL | MySQL | Medium | Exposure check |
This prevents random testing.
37. Don't Get Stuck
If a path isn't working:
Stop ↓ Review evidence ↓ Check assumptions ↓ Try another hypothesis ↓ Enumerate more
Don't spend two hours forcing an exploit because:
“This must be the intended way.”
CTFs sometimes have multiple paths.
38. Bug Bounty vs CTF Mindset
Bug bounty
Safety Scope Impact Evidence Responsible disclosure
CTF
Enumeration Exploration Exploitation Privilege escalation Flag
Bug bounty asks:
“Is this a real security problem?”
CTF asks:
“Can I solve this challenge?”
39. Bug Bounty Automation
You can combine your tools:
Subfinder ↓ Httpx ↓ Nuclei ↓ Wayback/URL discovery ↓ FFUF ↓ Burp ↓ Manual validation
But don't blindly automate attacks against real programs.
Automation should help you:
Discover and prioritize.
Manual testing should determine:
Whether something is actually vulnerable.
40. Build Your Own Recon Pipeline
Because you know Python, you can eventually create:
domains.txt ↓ Subdomain Discovery ↓ DNS Resolution ↓ HTTP Probing ↓ Technology Detection ↓ URL Collection ↓ Endpoint Extraction ↓ Nuclei ↓ Manual Testing
Example project:
bugbounty-recon/ │ ├── scope.txt ├── subdomains.txt ├── live.txt ├── urls.txt ├── screenshots/ ├── findings/ └── notes.md
This is a very useful portfolio project.
41. Prioritize Your Time
Suppose you find:
500 URLs 20 APIs 10 login pages 5 admin panels 2 file uploads 1 payment system
Don't test everything equally.
Prioritize:
Authentication ↓ Authorization ↓ Sensitive APIs ↓ Admin functionality ↓ File upload ↓ Business logic ↓ High-value assets
This is risk-based testing.
42. Common Beginner Mistakes
❌ Scanning everything blindly
Instead:
Understand scope → prioritize
❌ Reporting every header issue
Instead:
Determine actual impact
❌ Finding XSS and stopping
Instead:
Determine victim + context + impact
❌ Running scanners only
Instead:
Scanner → hypothesis → manual validation
❌ Ignoring authorization
This is a major mistake.
❌ Ignoring business logic
Some of the most interesting bugs aren't detectable by scanners.
43. Bug Bounty Research Mindset
When you find an interesting endpoint:
What does it do? ↓ Who can call it? ↓ What parameters? ↓ What objects? ↓ What happens if I change them? ↓ What assumptions does the server make? ↓ Can I cross a security boundary?
That mindset is far more important than memorizing payloads.
44. Your Practice Platforms
For legal practice, use:
- TryHackMe
- Hack The Box
- PortSwigger Web Security Academy
- OWASP Juice Shop
- DVWA
- Metasploitable
- Authorized bug bounty programs
These give you different types of practice.
45. Build a Vulnerability Portfolio
Instead of saying:
“I know ethical hacking.”
Build evidence of your learning.
Example:
Security Portfolio │ ├── Web Security │ ├── XSS lab │ ├── SQLi lab │ └── IDOR/BOLA lab │ ├── Network │ ├── Nmap analysis │ └── Service enumeration │ ├── AD │ └── Attack-path lab │ ├── IoT │ └── ESP32 security lab │ ├── Cloud │ └── IAM security lab │ └── Automation └── Python recon tool
This is much stronger for internships/jobs.
46. Your Bug Bounty Learning Loop
Use:
Learn ↓ Lab ↓ Break ↓ Understand ↓ Document ↓ Automate ↓ Repeat
For every vulnerability:
What is it? Why does it happen? How do I detect it? How do I validate it? What is the impact? How is it fixed?
47. CTF Learning Loop
Recon ↓ Enumeration ↓ Hypothesis ↓ Exploit ↓ Initial Access ↓ Enumeration Again ↓ Privilege Escalation ↓ Flag ↓ Writeup
Notice something important:
Enumeration happens again after initial access.
Because the environment looks different once you're inside.
48. Final Bug Bounty/CTF Mindset 🧠
Don't become:
“I know 500 payloads.”
Become:
“I can understand an application, identify its trust boundaries, discover attack paths, validate vulnerabilities safely, explain their impact, and document them professionally.”
That's the real goal.