Skip to content
Tutorials Center
My learning

Topics

Lesson 36 of 38 ยท Projects and Practice

Project: Run a Full Web Assessment Step by Step

Follow a complete, repeatable web application assessment with Burp: recon, mapping, authentication, access control, input handling, logic, and reporting, tracked with a Python checklist.

A beginner opens Burp, clicks around, and hopes to stumble on a bug. A professional follows a methodology: a repeatable sequence that covers the application systematically, so nothing important is skipped and the work can be shown to a client. In this project you apply everything from this track to a lab application and track your progress with a small checklist program.

Use only your own lab from the previous project. Burp screens are labelled examples; the Python code is a stand-in you can run here.

The phases

flowchart TD
  A["1. Scope and setup"] --> B["2. Map the application"]
  B --> C["3. Analyse the client side<br/>and technology"]
  C --> D["4. Authentication<br/>and sessions"]
  D --> E["5. Authorisation<br/>(access control)"]
  E --> F["6. Input handling<br/>(injection, XSS, SSRF)"]
  F --> G["7. Business logic<br/>and configuration"]
  G --> H["8. Scan, triage<br/>and verify"]
  H --> I["9. Report and re-test"]

Phases follow the OWASP Web Security Testing Guide, adjusted to the Burp workflow.

Phase 1: scope and setup

Rules of engagement, test accounts for every role, project file, scope configured, logging on. Do not move on until scope is written and the lab is reset-able.

Phase 2: map the application

Browse every feature with the proxy on. Then use the crawler (crawl only) to find what you missed. In the site map note: entry points (forms, API endpoints), unusual file types, hidden paths from robots.txt and sitemap.xml, and JavaScript files. Use Engagement tools: Discover content (Professional) to find unlinked paths, and Target analyzer to see parameters and technology. Record every role and every workflow (register, login, checkout, reset, upload).

Phase 3: the client side and technology

Check the response headers for the stack (Server, X-Powered-By), security headers (CSP, HSTS, X-Content-Type-Options, frame protections), cookies and their flags, and the JavaScript for API endpoints, secrets in comments, and framework versions. Passive scan findings land here. Question what the browser enforces versus what the server enforces: anything enforced only in the browser can be bypassed in Repeater.

Phase 4: authentication and sessions

Apply login and lockout testing, password-reset and registration checks, Sequencer on tokens, logout invalidation, session fixation, and JWT checks if tokens are used.

Phase 5: authorisation

Build the role matrix and replay requests across accounts: horizontal and vertical checks, IDOR, method switching. This is usually where the highest-impact findings hide.

Phase 6: input handling

Run probes against every input from the map: SQL injection, XSS, SSRF and out-of-band, plus path traversal in file parameters, command injection in features that call system tools, XML external entities in XML input, template injection in anything rendered from text, and file-upload handling (type, size, storage location, execution).

Phase 7: business logic and configuration

Think like a user with bad intentions: negative quantities, skipped steps, reused coupons, race conditions on "only once" actions (send many parallel requests with Repeater's group send), price tampering, workflow bypass, CSRF and CORS, verbose errors, debug endpoints, default credentials, exposed backups. These are the issues scanners cannot see.

Phase 8: scan, triage and verify

Only now run the Scanner, in a controlled configuration (Scanner basics and configurations). Treat results as leads, and apply triage. Doing manual work first gives you the context to judge the scan.

Phase 9: report and re-test

Write findings, build the report, and verify fixes.

Track it with a checklist

Methodology only works if you can see what is done. This stand-in is a tiny checklist tracker: it stores tasks by phase, marks them done, and prints progress. Adapt it for your lab notes.

Python Assessment checklist tracker (stand-in)

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Change the done set as you work. A phase that stays at 0 for hours means you are skipping a whole class of bugs.

Time-boxing and note-taking

Give each phase a budget (for a small app: mapping 1 hour, authentication 1 hour, authorisation 2 hours, input 2 hours, logic 2 hours, scan and triage 1 hour, report 3 hours). When the budget ends, note what you did not test and move on. Notes should say what you tried, what you saw, and what you concluded, even for negative results; they back up the "tested, not vulnerable" statements in the report.

The deliverable for this project

Produce, from your own lab:

  1. A scope document.
  2. A completed checklist.
  3. At least five findings written in the standard structure, each with a request/response excerpt (redacted) and a CVSS vector.
  4. A short report (executive summary plus findings table).
  5. A re-test table after you "fix" two of the issues in your own copy of the lab.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Why follow a methodology instead of clicking around?

    A methodology ensures coverage and gives evidence that areas were tested.
  2. 2. Why is manual work done before the full scan?

    Knowing the application lets you judge which scanner findings are real and relevant.
  3. 3. Which phase usually contains logic flaws such as skipping a checkout step?

    Logic flaws need human reasoning about how the application is supposed to behave.
  4. 4. What should you record for areas where you found nothing?

    Negative results are evidence of coverage and support honest reporting.

Summary

  • Work through phases: scope, mapping, client side, authentication, authorisation, input, logic and configuration, scan and triage, report and re-test.
  • Manual testing comes first; the scanner adds coverage and needs triage.
  • Track progress with a checklist and time-box each phase.
  • Record negative results too, and keep evidence for every finding.
  • The deliverable is a scope document, checklist, findings, report and re-test table from your own lab.

Next: Project: parse a proxy history export