Repository navigation
Web Application Penetration Testing Methodology
Caution
Authorized use only. This methodology is for authorized penetration testing, education, and defensive research. Only test applications you own or have explicit written permission and a signed scope to assess. See LEGAL.md.
Standards and reporting companion: OWASP ASVS 5.0.0, WSTG scenarios and reviewed Nuclei templates provide versioned controls and source provenance for the testing phases below; findings workflow tracks verification and retests.
A repeatable, phase-by-phase methodology for authorized web application assessments - from scoping through reporting - aligned with the OWASP Web Security Testing Guide.
Covers pre-engagement scoping, reconnaissance and mapping, a practical Burp Suite workflow, configuration/authentication/authorization/input/business-logic testing, API and GraphQL testing, and reporting. Complements the OWASP Top 10 deep-dive, which details the individual risk classes.
Enable a tester to run a consistent, thorough web assessment that maps findings to OWASP/CWE with reproducible evidence and actionable remediation.
- Executing an authorized web application or API penetration test
- Standardizing a team's web testing workflow and tooling
- Preparing a scoped methodology for a client engagement
- Phase 0: Scoping & Rules of Engagement
- Phase 1: Reconnaissance & Mapping
- Phase 2: Burp Suite Workflow
- Phase 3: Configuration & Deployment Testing
- Phase 4: Authentication & Session Testing
- Phase 5: Authorization Testing
- Phase 6: Input & Injection Testing
- Phase 7: Business Logic Testing
- Phase 8: API & GraphQL Testing
- Phase 9: Reporting
- Tooling Reference
- Resources
Before any traffic is sent:
- Confirm written authorization, in-scope hosts/domains, and excluded targets.
- Agree testing windows, rate limits, and whether destructive tests (e.g. DoS, mass data modification) are permitted (usually not).
- Identify test accounts (ideally two per role for access-control testing).
- Establish an emergency contact and a stop condition.
- Record everything - scope defines what is legal to touch. See LEGAL.md and the OSINT Playbook for engagement-documentation patterns.
Build a complete picture of the application before testing it.
- Passive: technology fingerprinting (Wappalyzer, response headers), subdomain and content discovery, JS review for endpoints and secrets. See OSINT/scripts/Domain_IP_Recon.md.
-
Active: spider/crawl the app, enumerate directories and parameters
(
ffuf,feroxbuster), map every role's reachable functionality. - Output: an endpoint/parameter inventory and a per-role functionality map - the input to every later phase.
# Content discovery (authorized scope only)
ffuf -u https://TARGET/FUZZ -w wordlist.txt -mc 200,204,301,302,401,403
feroxbuster -u https://TARGET -w wordlist.txt
# Passive tech/endpoint hints
curl -sI https://TARGET # headers: server, framework, security headersBurp Suite (Community or Professional) is the core interception proxy.
- Proxy setup: route the browser through Burp; install Burp's CA cert for TLS.
- Target scope: define the approved hosts and paths, and configure each tool to operate only on the intended targets. Scope filters and steers Burp tools; it does not grant authorization or necessarily block every out-of-scope request. Where your Burp version and project settings provide it, enable Drop all out-of-scope requests, and still review destinations, redirects, extensions, and manual requests against the signed rules of engagement. See PortSwigger's scope guide and out-of-scope request handling settings.
- Crawl & map: browse the app to populate the site map; review every request.
- Repeater: manually manipulate individual requests to probe behavior.
- Intruder: automate payload injection (fuzzing, brute force) within scope.
- Decoder / Comparer: encode/decode data and diff responses.
- Extensions (BApp Store): Autorize/Auth Analyzer (access control), Logger++, JWT Editor, Param Miner, Active Scan++.
- Scanner (Pro): automated scanning to complement - not replace - manual testing.
Conceptual workflow: configure scope as an operational safeguard, while written authorization and review of each action remain the controlling boundaries.
Tip
Automated scanners find the easy issues; access-control and business-logic flaws almost always require manual testing with two accounts and an understanding of the app's intent.
Maps to A02 Security Misconfiguration and A04 Cryptographic Failures.
- TLS configuration and certificate validity; HSTS.
- Security headers: CSP,
X-Content-Type-Options,Referrer-Policy, frame options. - Exposed files:
.git/, backups,/actuator,.env, source maps, admin consoles. - CORS policy (test with a rogue
Origin); cookie flags (HttpOnly,Secure,SameSite). - Default credentials on any administrative surface.
Maps to A07 Authentication Failures.
- Login: rate limiting / lockout, username enumeration, credential stuffing exposure.
- Password reset and MFA flows for bypasses and information leaks.
- Session lifecycle: fixation, rotation on privilege change, invalidation on logout, idle/absolute expiry.
- Tokens/JWT: validate
algand signature server-side; check foralg:none, weak secrets, missing expiry, and sensitive claims.
Maps to A01 Broken Access Control - the highest-prevalence risk, and the phase automation misses most.
- Horizontal: with two same-role accounts, replay each user's requests as the other; increment/swap object identifiers (IDOR).
- Vertical: attempt admin/privileged functionality as a low-privileged user; request privileged endpoints directly (forced browsing).
- Method/param tampering: change HTTP verbs, toggle role parameters, remove authorization headers.
- Use Burp Autorize/Auth Analyzer to systematize the two-account replay.
Maps to A05 Injection.
- Fuzz every input surface (query/body/path/headers/JSON) with context-specific payloads; observe reflected, stored, and DOM contexts for XSS.
- SQL/NoSQL injection: confirm manually, then
sqlmapwithin scope. - Command and template injection (SSTI); LDAP/XPath where applicable.
- File upload: type/content validation, path traversal, dangerous extensions.
# SQL injection confirmation (authorized scope only)
sqlmap -u "https://TARGET/item?id=1" --batch --risk=1 --level=1
# note: coordinate risk/level and data-modifying options with the ROEMaps to A06 Insecure Design. These flaws abuse legitimate functionality and require understanding the app's intent.
- Workflow bypasses (skip steps, replay, out-of-order requests).
- Value/quantity tampering (negative amounts, price manipulation, coupon reuse).
- Missing anti-automation on sensitive actions (OTP, reset, checkout).
- Race conditions on state-changing operations (concurrent requests).
APIs are a major modern attack surface (see the OWASP API Security Top 10).
- REST: enumerate endpoints (Swagger/OpenAPI if exposed); test object- and function-level authorization (BOLA/BFLA - the API analogue of A01); mass assignment; excessive data exposure; rate limiting.
- GraphQL: attempt introspection to map the schema; test authorization per resolver; watch for nested-query/batching abuse (DoS) and injection via arguments.
- Tooling: Burp, Postman,
graphql-cog/clairvoyance(introspection), and the OWASP API Security Top 10.
- GraphQLmap β scriptable GraphQL endpoint exploration and field testing for the approved target scope; use test accounts, non-destructive queries, and rate limits.
- PayloadsAllTheThings and HackTricks β technique references for planning test cases and finding corresponding mitigations. These contain potentially disruptive examples; review and adapt, rather than copying or executing them against production services.
See the API/GraphQL phase above, and record authorization, inputs, impact and reproduction requirements before conducting tests.
- Each finding: title, severity (with CVSS where useful), affected endpoint, reproducible steps/evidence, impact, and remediation.
- Map findings to OWASP Top 10 categories and CWE IDs.
- Separate confirmed vulnerabilities from informational/hardening observations.
- Provide an executive summary and a prioritized remediation roadmap.
| Tool | Role |
|---|---|
| Burp Suite | Interception proxy, repeater, intruder, scanner |
| OWASP ZAP | Open-source proxy/scanner alternative |
| ffuf / feroxbuster | Content & parameter discovery |
| sqlmap | SQL injection confirmation/exploitation |
| nuclei | Template-based vulnerability scanning |
| Postman | API request crafting |
| jwt_tool | JWT analysis and attacks |
- OWASP Web Security Testing Guide - the definitive methodology
- OWASP API Security Top 10 - API-specific risks
- OWASP ASVS - verification requirements
- PortSwigger Web Security Academy - hands-on labs
- README.md - Web Application Security section index
- owasp-top-10.md - the risk classes this methodology tests for
- ../OSINT/scripts/Domain_IP_Recon.md - recon that feeds Phase 1
- ../IncidentResponse/SIEM/README.md - the defensive/detection side
Section Index | Master Index | Legal Notice
π Source: WebAppSecurity/methodology.md | βοΈ Suggest an edit | β¬
οΈ Back to Web App Security
- πΊοΈ Browse by Topic
- π All Repository Files
- π§ Learning Paths
- π Master Guide
- π€ Glossary
- βοΈ Legal & Disclaimer
π Foundations & Learning
π‘οΈ Defense & Investigations
- Incident Response
- Open Source Intelligence (OSINT)
- Reverse Engineering
- Operations Security (OPSEC)
- Compliance
βοΈ Platforms & Infrastructure
π‘ Hardware, Wireless & Field Projects
- PNWC Cyberdeck
- Hardware Testing
- Hardware Hacking
- Software-Defined Radio
- Wardriving
- uConsole
- Space Security
π§° Assessment & Field Reference
π¦ Downloads & Project Resources
ποΈ Additional Topics