Bugbountyandctf

13 min read2,583 words

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 BountyCTF
Real systemsDeliberately vulnerable systems
Real business impactChallenge/learning objective
Strict scopeDefined challenge environment
Professional reportUsually flag submission
Responsible disclosureCompetition/education
Often unpredictableUsually 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

PortServiceVersionInteresting?Next Action
22SSHOpenSSHYesCredentials
80HTTPApacheHighWeb enum
445SMBSambaHighShare enum
3306MySQLMySQLMediumExposure 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.

Keep learning. Keep building. Keep growing.

© 2026 Ugenz Academy