Skip to content
Tutorials Center
My learning

Topics

Lesson 22 of 38 ยท Scanner and Extensions

Triaging Scanner Findings and False Positives

Learn a repeatable way to triage Burp Scanner issues: read severity and confidence, reproduce in Repeater, spot false positives, and record evidence for the report.

A scan finishes and the Dashboard shows 40 issues. Now the real work starts. Some are real and serious, some are real but trivial, and some are false positives: Burp reported a problem that is not there. Sending all 40 to a client unchecked would waste their time and damage your credibility. Triage is the habit of deciding, one issue at a time, what is true, how bad it is, and what evidence proves it.

The Burp output below is labelled example output; the Python block is a stand-in for the idea of ranking findings.

The triage loop

flowchart TD
  A["Read the issue:<br/>name, severity, confidence"] --> B["Open the request<br/>and response evidence"]
  B --> C["Replay in Repeater<br/>(change one thing)"]
  C --> D{"Reproduced?"}
  D -- Yes --> E["Assess real impact<br/>and note evidence"]
  D -- No --> F["Mark false positive<br/>and write why"]
  E --> G["Keep for report"]

Every finding ends in one of two states: confirmed with evidence, or dismissed with a reason.

Step 1: read the metadata

Each issue carries:

  • Severity: High, Medium, Low or Information, based on the typical impact of that class of bug.
  • Confidence: Certain, Firm or Tentative, based on how conclusive Burp's evidence was.
  • Path and insertion point: the URL and the parameter or header involved.
  • Issue background / remediation: a short explanation you can adapt.

Start with High and Medium issues that are Firm or Certain. Then look at Tentative ones. Information-level items are usually things for the notes, not for the headline findings.

Step 2: read the evidence

Every active finding stores one or more request/response pairs. The Advisory tab explains the issue; the Request and Response tabs show exactly what triggered it. Burp highlights the matching part of the response. Ask yourself: does this response really show what the advisory claims?

TEXT
Issue: SQL injection (Tentative)    Path: /products?id=7
Evidence: payload  id=7'   -> response contains "You have an error in your SQL syntax"
          payload  id=7''  -> normal page
Confidence note: error message differs between one and two quotes

That quote-pair pattern is a strong sign of a real problem. If instead the evidence only shows one response with a slightly different length, be more doubtful.

Step 3: reproduce by hand

Right-click the issue and choose Send to Repeater. Reproduce it by hand in the safest way possible: re-send the benign trigger, compare against a control, and change one thing at a time. Your goal is to explain why the response changed. If you cannot explain it, you do not yet understand the finding.

Common causes of false positives

Pattern Why it fools the scanner How to check
Reflected payload in a harmless place Text appears in an HTTP response header or JSON string where it cannot run Look at the content type and where the text sits
Generic error page A 500 appears for any unusual input, not just a specific attack Send random junk of the same shape
Timing noise A slow network makes a time-based test look like a hit Repeat several times, compare with a no-delay control
Shared hosting / CDN A WAF or CDN rewrites responses Check response headers, retest with different input
Dynamic page content A timestamp or ad block differs on every load, so "different response" fires Reload the original twice; if they differ already, the test is meaningless

Check for baseline noise

Many "boolean-based" findings compare a normal response to a modified one. If two identical requests already differ, a difference proves nothing. This stand-in measures the noise first, and only then judges a candidate.

Python Judge a response change against baseline noise (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.

A real tester does the same in Repeater: send the original request three times first and note what naturally changes.

Impact beats label

A "High" label from a scanner is the class of issue; real impact depends on the context. A stored XSS on an admin-only page that only you can reach is different from one on a public comment form. When you confirm a finding, write the real-world sentence: who is affected, what an attacker needs, what they gain.

A small prioritiser

This model turns a list of findings into a triage order using severity, confidence and a rough "reachable by anonymous user" flag. It shows the thinking; it is not a Burp feature.

Python Rank findings for triage (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.

Notice that the tentative SQL injection still comes first: its potential impact is large, so it earns attention until you disprove it.

Record as you go

For each finding keep: the request that proves it (copy as curl or save from Repeater), the response snippet, the date and time, the account used, and your verdict. Burp's Add note and Highlight features (Proxy history, right-click) are ideal. Writing the evidence while it is fresh makes the report a copy-and-polish job rather than archaeology.

If you find evidence of real personal data while testing, stop, record minimal proof (for example, one redacted record), and tell the system owner as agreed in your rules of engagement. Never collect more data than needed to prove the issue.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What does the confidence rating express?

    Confidence (Certain, Firm, Tentative) describes the strength of Burp's evidence, separate from severity.
  2. 2. Why measure baseline noise before judging a response difference?

    Dynamic content such as timestamps can make two normal responses differ, causing false positives.
  3. 3. What is the best first step after a scanner reports a High issue?

    Reproduce and understand the finding before reporting it.
  4. 4. When testing one change at a time in Repeater, why use a control request?

    A control shows what is normal, so differences can be attributed to your change.

Summary

  • Triage turns raw scanner output into confirmed findings with evidence, or dismissed ones with reasons.
  • Read severity and confidence, inspect evidence, then reproduce one change at a time in Repeater.
  • Typical false positives: harmless reflections, generic errors, timing noise, CDN rewriting and dynamic content.
  • Judge real impact in context, and record evidence as you go.
  • Minimise data exposure while proving an issue.

Next: Extensions and the BApp Store