Skip to content
Tutorials Center
My learning

Topics

Lesson 34 of 38 ยท Reporting

Building the Report, Exporting Evidence and Re-testing

Learn how to assemble a penetration test report from Burp: save project state, export issues, structure the document, assemble evidence safely, and verify fixes in a re-test.

You have confirmed findings and rated them. Now you assemble the deliverable: a report that a manager can act on, a developer can reproduce from, and an auditor can trust. This lesson covers how to collect evidence from Burp, how to structure the document, how to export and handle the data responsibly, and how to run the re-test after the client fixes things.

The Burp menus are described as labelled examples; the Python blocks are offline stand-ins that assemble a report from structured data.

Collect evidence while you work

The cheapest way to a good report is good habits during testing:

  • Keep one Burp project file per engagement (Burp Suite Professional: Project file, Save; temporary projects vanish when you close Burp). Name it with client, date and scope.
  • Use Add comment and Highlight in Proxy history to mark interesting requests the moment you find them.
  • Copy exact requests with right-click, Copy as curl command or Copy to file, and keep them in a findings folder named by finding ID.
  • Take screenshots with timestamps for browser-visible results.
  • Keep a testing log: start and end times, source IP address, accounts used. Clients often need it to separate your traffic from a real attack in their logs.

Exporting from Burp

Burp Suite Professional can Report issues from the Dashboard or Target tab (select issues, right-click, Report selected issues). Options:

Choice Effect
HTML or XML format HTML reads well; XML can be processed by scripts
Issue detail level Headings only, summary, or full with requests and responses
Include issue types Which severities to include
Report title and theme Branding and layout

Treat the default report as raw material. It shows scanner advisories, but a client wants your verified findings, risk rating and remediation. Many consultants export the XML and merge it into their own template, as the example below does.

An exported project file or report contains real credentials, session cookies and customer data captured during testing. Store it encrypted, share it only through the agreed secure channel, and delete it at the end of the retention period stated in the contract.

Structure of a report

  1. Cover and document control: client, dates, version, classification.
  2. Executive summary: one page, plain language, overall risk, the top three issues, what to do first. No jargon.
  3. Scope and methodology: which hosts and roles were tested, test window, approach (for example OWASP Web Security Testing Guide, OWASP ASVS), tools (Burp Suite version).
  4. Summary of findings: a table sorted by severity, with IDs.
  5. Detailed findings: each in the structure from the previous lesson.
  6. Positive observations: controls that worked well; clients appreciate it and it makes the report credible.
  7. Limitations: what was out of scope, what could not be tested.
  8. Appendices: methodology details, request logs, tool output.
flowchart LR
  A["Burp project +<br/>notes + screenshots"] --> B["Findings data<br/>(structured)"]
  B --> C["Report template"]
  C --> D["Draft report"]
  D --> E["Peer review<br/>(accuracy, redaction)"]
  E --> F["Delivered report"]
  F --> G["Client fixes"]
  G --> H["Re-test<br/>and retest addendum"]

Keep findings as structured data so the report is generated, not retyped.

Generate a report from structured data

This stand-in takes findings as dictionaries, sorts them by severity, and creates a summary table plus a detail section in Markdown. It is the same idea as merging Burp's XML into a template.

Python Assemble a report from findings data (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.

Redact before you share

Reports must not leak the secrets you captured. A small helper that masks cookies, tokens and passwords in pasted requests avoids mistakes.

Python Mask secrets in request evidence (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.

The re-test

After the client fixes issues, you verify. A re-test is a targeted exercise, not a new full test:

  1. Agree the scope: the findings to verify, the same environment and test accounts, and the build or date of the fixes.
  2. For each finding, repeat the exact reproduction steps. Reuse the saved Repeater requests and the saved scan configuration for comparability.
  3. Also test around the fix: a patched category parameter may leave sort injectable; a blocklist may have a bypass; a fix on one endpoint may not cover its sibling.
  4. Record the result: Fixed, Partially fixed (explain), Not fixed, or Risk accepted (the client decided not to fix).
  5. Issue a short re-test addendum with the date, build tested and a status table, and do not rewrite the original report; keep a clear history.
ID Original severity Re-test result Notes
F-01 Medium Fixed Returns 403 for non-owners
F-02 Low Fixed HttpOnly present
F-03 Critical Partially fixed Parameter fixed, sort still injectable

Delivery and follow-up

Offer a short walkthrough call for the client's developers: ten minutes watching you reproduce a finding in Burp saves hours of confusion. Share the report through the agreed encrypted channel, confirm receipt, and log the retention and deletion date of your own copies of project files.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. Why keep one Burp project file per engagement?

    A saved project preserves history and evidence for the report and the re-test.
  2. 2. What should the executive summary avoid?

    It is written for non-technical readers; details belong in the findings.
  3. 3. Why redact tokens and passwords in reports?

    Evidence that includes live secrets becomes a security risk itself.
  4. 4. What is a re-test?

    A re-test verifies fixes using the original reproduction steps and tests around them.
  5. 5. A parameter is fixed but a sibling parameter is still injectable. What status is right?

    The reported entry point is fixed, but the same weakness remains elsewhere.

Summary

  • Collect evidence while testing: project file, notes, highlights, copied requests and screenshots.
  • Use Burp's issue export as raw material and merge into your own template from structured data.
  • A report has executive summary, scope, findings table, detailed findings, positives, limitations and appendices.
  • Redact secrets; protect and delete project files per the contract.
  • Re-test with the original steps, test around the fix, and issue an addendum.

Next: Project: build a lab and define scope