Skip to content

Web Application Penetration Testing Methodology

github-actions[bot] edited this page Nov 19, 2026 · 2 revisions

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.

🎯 Purpose

A repeatable, phase-by-phase methodology for authorized web application assessments - from scoping through reporting - aligned with the OWASP Web Security Testing Guide.

βš™οΈ Function

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.

πŸ† Goal

Enable a tester to run a consistent, thorough web assessment that maps findings to OWASP/CWE with reproducible evidence and actionable remediation.

πŸ“‹ When to Use

  • 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

πŸ“‹ Table of Contents


Phase 0: Scoping & Rules of Engagement

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.

Phase 1: Reconnaissance & Mapping

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 headers

Phase 2: Burp Suite Workflow

Burp Suite (Community or Professional) is the core interception proxy.

  1. Proxy setup: route the browser through Burp; install Burp's CA cert for TLS.
  2. 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.
  3. Crawl & map: browse the app to populate the site map; review every request.
  4. Repeater: manually manipulate individual requests to probe behavior.
  5. Intruder: automate payload injection (fuzzing, brute force) within scope.
  6. Decoder / Comparer: encode/decode data and diff responses.
  7. Extensions (BApp Store): Autorize/Auth Analyzer (access control), Logger++, JWT Editor, Param Miner, Active Scan++.
  8. Scanner (Pro): automated scanning to complement - not replace - manual testing.

Workflow showing authorization, target boundaries, Burp scope settings, request review, and stop conditions

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.


Phase 3: Configuration & Deployment Testing

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.

Phase 4: Authentication & Session Testing

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 alg and signature server-side; check for alg:none, weak secrets, missing expiry, and sensitive claims.

Phase 5: Authorization Testing

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.

Phase 6: Input & Injection Testing

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 sqlmap within 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 ROE

Phase 7: Business Logic Testing

Maps 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).

Phase 8: API & GraphQL Testing

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.

Starred references for authorized web/API assessments

  • 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.

Phase 9: Reporting

  • 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.

πŸ› οΈ Tooling Reference

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

πŸ“š Resources


Related Files


Section Index | Master Index | Legal Notice


πŸ“„ Source: WebAppSecurity/methodology.md | ✏️ Suggest an edit | ⬅️ Back to Web App Security

Clone this wiki locally