Is this DAST finding real? A guide to the 21-post series on confirming dynamic scan findings: the evidence classes, what each one can and cannot prove, the ways a clean result misleads, and the question, strongest evidence and usual mis-triage for every finding type

DedSec Security Research ·

A dynamic scanner hands you a title, a severity and a piece of evidence. The title says what the scanner was testing for. The severity is somebody's estimate of how bad that class of bug usually is. The evidence is the only part that describes your application, and it is usually one observation: a string that came back, a response that took longer, a callback that arrived, two pages that differed.

Over twenty-one posts we took one finding type, or one tool's output, at a time and asked the same two questions of it: what did the scanner actually observe, and what can that observation prove? Each post opens with a hypothetical scan that returns two to five results, and a team that triages them from the title, the rating or a belief about the application, rather than from what was observed. Across those scenarios, confident calls go wrong in both directions: a high that proves nothing, and a low or a clean result that turns out to be the most serious finding in the set. Many of the posts then rebuild those situations in a local lab and measure what the evidence does and does not show.

This page is the index to that series, and it is meant to be useful without the other twenty-one. It covers:

Sources, and how this was checked. This post makes no new measurements and reports no new lab results. Every mechanism, result and number below appears in the linked post, which records how it was measured, on which versions, and what it did not measure. Where a post presents something as part of a hypothetical scenario, it is described as a scenario here too. One post measured nothing: the reflected XSS post says that no number in it is a measurement of any tool. Where a post says it did not test something, this guide does not suggest otherwise. Three earlier posts come up throughout the series and are linked where they apply: why "the scan passed" is not "the scan ran", what a DAST crawler never saw and out-of-band testing.

A finding is a claim, and the claim has parts

The series' first move, in most posts, is to write down the claim the finding has to support and then notice that the evidence supports only part of it. Several posts make the split explicit:

The tool-output posts make the same point about the tools themselves. A Nuclei result says that a set of conditions, written by a template author, evaluated to true against one response or a sequence of them. An ffuf hit is a response that passed the matchers and was not removed by the filters. "Found" in Arjun's output means a response changed. None of these is a statement that a vulnerability or a resource exists.

The severity attached to a finding does not move with the strength of the evidence. The Nuclei post quotes the template contribution guide telling authors to set severity "Based on the CVSS score but can vary based on the exploit and real-world impact", and notes that a critical on a version-only template and a critical on a computed-marker RCE template are the same word in the output. The series repeatedly rates a finding from what its evidence class can prove, not from the CWE number or the title.

The evidence classes, and what each can prove

These are the kinds of observation that recur across the series. They are not a ranking. The same class can be strong for one finding type and weak for another, and the posts show where each was fooled.

The input came back

The cheapest evidence, and the one behind most false positives. A unique marker is sent and found in the response. That proves the input reaches the response, and nothing about what happened to it on the way.

The series found literal reflections passing for other bugs again and again. A command-injection marker qzxv came back because a diagnostics page printed "Results for" followed by the host value. A path-traversal matcher on the word etc/passwd fired on a 404 that echoed the path, a WAF block page that echoed the URL and an error message that printed the joined path. An open-redirect marker sat in a Location header that resolved to the application's own host. A CRLF marker sat inside a Location header with the carriage return and line feed still percent-encoded. A Host header canary appeared in a sentence of display text, inside no URL.

What makes reflection useful is reading where it landed. The XSS post's whole argument is that the output context decides which characters matter: a raw angle bracket inside a quoted attribute is harmless, a raw double quote there is not, and a reflection in JSON or text/plain with nosniff does not execute on navigation.

A value the request did not contain

The strongest in-band evidence the series found is a response that contains something only the vulnerable code could have produced. A reflection returns the input unchanged and cannot satisfy it. The series uses three forms:

Each form has a known trap, and the series measured or described all three:

The confirmation that recurs is to change the input and watch the output follow: a different expression ($((7*9))), a non-arithmetic probe ({{'abc'|upper}} returning ABC), or the bare last path component alone.

Differential responses

When nothing useful comes back, the evidence is a difference between responses. The SQL injection post sets the standard later posts reuse: three responses, not two (baseline, true and false), and two phrasings of each condition, so that the response is seen to follow the truth of the expression rather than its text. A search box can return different results for AND 1=1 and AND 1=2 because one contains the token "2". Before trusting any difference, diff the baseline against itself and exclude whatever changes between identical requests.

Differentials were fooled throughout the series:

The strongest differentials are pairs that should be identical only if the vulnerable behaviour happened. The path traversal post's out-and-back pair, report.txt and ../files/report.txt, returned identical bodies and proved traversal without reading anything outside the application's own directory.

A confirmed boolean differential is not a weak finding. The SQL injection post quotes sqlmap's documentation describing extraction "character by character" at "about seven HTTP requests" per plain ASCII character. Given enough requests, a boolean oracle reads anything the database account can read.

Timing

A response that took longer than usual shows that something waited. The series' rule, from the SQL injection post on, is that one slow response is not a finding. The controls are repetition interleaved with controls, graded delays (0, 2, 4 and 6 seconds) whose response times rise in step, a conditional version whose delay follows the condition, and a baseline distribution rather than a baseline number.

The posts found the delay coming from somewhere other than the payload again and again:

The command injection post adds a useful asymmetry. It measured sh -c "sleep N" at N seconds plus 2 to 6 milliseconds, so the delay a payload asks for is the delay the command produces. The noise is everything around the command. The same post's queued route returned in 1 millisecond while its worker ran every payload. A time-based scanner would have reported it clean.

Timing probes also cost something. The NoSQL post's $where finding took ten seconds because twenty documents each slept 500 ms. The probe was a load test against the collection.

Errors

An error is a lead whose value depends on which component produced it. The series' clearest example is from the SQL injection post's PostgreSQL 16 container. unterminated quoted string means a quote reached SQL syntax. invalid input syntax for type integer: "1'", from a bound parameter, means the input arrived as data and was rejected when the database tried to convert it. A scanner that matches on "syntax" raises both. The second is an information-disclosure finding, not an injection.

The same distinction recurs:

An error that discloses something is often a second finding worth keeping. The path traversal scenario's "Invalid file type for /srv/app/reports/../../../../etc/passwd" gave away the base directory, its depth and the fact that the path was joined without normalisation. It led to the real finding: a cross-tenant read of PDF files.

Out-of-band callbacks

The target contacts a server the tester controls, usually a unique hostname per payload. The series treats the channel and the content of the callback as the evidence, not its arrival:

Silence is not a clean result. A host with no outbound DNS or HTTP never calls back, however injectable the parameter is.

Artefacts written, planted or fetched

Some findings are confirmed by a file:

The file upload post adds that a fix must be verified by fetching too. In its scenario, a <Directory> fix looked right in the configuration, and on the lab's A4 placement .php, .phtml, .phar and .jpg.php all still executed.

An effect seen by a second party, a second identity or a real browser

For a whole family of findings, the decisive observation is not in the scanner's response at all:

This is also where deliverability lives. The XSS post points out that an attacker's page generally cannot make a victim's browser set a custom header on a cross-site navigation, so a reflection that needs one is a different finding from one in a query string.

Failure modes that recur across finding types

The title and the rating decide the triage

Nearly every post makes the same observation about its scenario: each decision rests on the title, or on the template's name and severity, rather than on what the scanner observed and what that observation can prove. In the scenarios it fails in both directions. The JWT post's "alg none accepted" critical was a public catalogue whose response was byte-for-byte the no-token response. The deserialization post's informational "Serialized object in cookie" was code execution. The GraphQL post's five findings were each closed on a sentence that sounded right ("rate limited at the gateway", "GET is only used for queries"), and in its lab each went the other way.

Something other than the application answered

Block pages, WAF responses, proxy errors, login redirects, catch-all routes, API gateways and caches all produce responses that look like a result. The series found them producing both false positives, when a matcher fired on them, and false negatives, when a parameter was recorded as clean. Examples:

The checklist item most posts end on is the same: before closing a parameter as clean, confirm the scanner reached the handler rather than a block page, an edge error or a login redirect.

The payload was changed before it arrived

curl's default and Node.js's fetch both resolved dot segments in the path before sending, and nginx returned 400 for paths above the root in every encoding the path traversal post tried. In the open redirect scenario, the scanner's own HTTP client followed /\marker.example/ back onto the application and concluded "same origin". Resolved with a WHATWG parser, it named marker.example. The open redirect post found that curl and Python clients disagreed with the WHATWG parser in both directions.

The effect happened somewhere the response does not show

Asynchronous and second-order sinks are invisible to a request-and-response diff:

The scanner tested the wrong shape of input

The run did not finish, and still exited cleanly

The scan-passed post makes the general argument.

A mitigation recorded as the fix

The series keeps separating "mitigated" from "fixed":

The retest replays only the original payload

The NoSQL post's scenario is the sharpest case. Middleware stripping $ keys stopped the operator payload, and "password": null still logged in an account with no password field. Most checklists in the series end the same way: retest with the evidence that raised the finding plus the other variants, through the same client settings, and against the application rather than a cache. For the deserialization scenario's serialized-object cookie, the retest has to listen out of band, because the response will look the same before and after.

A clean result is not "not vulnerable"

Most scenarios from the open redirect post onward include a clean result, or a finding the scan never raised. Each of these turned out to be a false negative: the open redirect /continue, the SSRF /import, the XXE /upload/avatar, the CRLF /track, the Host header /forgot-password, the request smuggling /assets/, the CORS and JWT /api/billing, the Arjun /api/profile and /export, the SSTI /newsletter/signup and /profile, and the CSRF change-password form that the scan never reported. In the Host header scenario, the reset form that reflected nothing was the most serious of the three findings. A clean result records that no observation matched. Most of the series' checklists end by asking what the scan actually tried.

The 21 posts, grouped by mechanism

Each entry gives the question the post answers, the strongest evidence for that finding type, and the most common way it is mis-triaged. The number is the post's position in the series.

Input that an interpreter evaluates

1. Reflected XSS: output context and confirmation. *Question:* a marker came back in the response, so is it cross-site scripting? *Strongest evidence:* a payload built for the output context, loaded in a real browser, firing a marker-specific callback. Structural confirmation, meaning the payload created an element or attribute, is one step below and proves injection, not execution. *Usual mis-triage:* closing a reflection because the angle brackets came back encoded in one place, when the same parameter also lands in a script string that leaves < alone. The worst context decides the finding.

2. SQL injection: boolean, time and error evidence. *Question:* did the input reach SQL syntax, or only a database? *Strongest evidence:* a value only the database could have computed from the payload. The post calls UNION-based extraction the strongest in-band evidence, and a boolean pair with three responses and two phrasings is a complete oracle. *Usual mis-triage:* reading a type-conversion error as injection, trusting one slow response, and closing a finding because "the ORM parameterises everything". In the scenario, the sort field went into a raw ordering expression, and it was not a value.

3. OS command injection. *Question:* did a shell run the input? *Strongest evidence:* a value only a shell could compute, such as INJ42 from INJ$((6*7)), repeated with a different expression. Out of band, the strongest form is an HTTP callback with the computed value in the path. *Usual mis-triage:* a literal marker that was the page printing its parameter; a DNS-only callback on a parameter whose job is to fetch a URL; and closing argument injection because the call uses a list with shell=False. In the scenario, --upload-pack ran a command through git anyway.

16. Server-side template injection. *Question:* did a template engine compile the input, and which engine? *Strongest evidence:* a computed result the request did not contain, from factors chosen for that request. It should be corroborated by a non-arithmetic probe and a valid-versus-broken pair, with the engine established by something other than 49. *Usual mis-triage:* an answer box that does arithmetic on purpose, an engine name inferred from one probe, and clean results from a welcome email and a path-keyed cache.

19. NoSQL injection: MongoDB operators. *Question:* what did the payload become by the time it reached the query: an operator, a missing field or a type error? *Strongest evidence:* a true-and-false pair that changes the outcome. A 500, a length change or a status change on its own is a lead. *Usual mis-triage:* a fix that strips $ keys, verified by resending only the operator payload; and a simple-parser finding closed as impossible. With the driver's ignoreUndefined: true, a missing password matched any value, and it still did behind express-mongo-sanitize.

Where a URL or reference leads

7. Open redirect. *Question:* does the redirect leave the site, and does anything trust it? *Strongest evidence:* the raw redirect target, resolved against the request URL with a WHATWG parser, with its origin compared to a unique marker host. Do not search the Location header for the marker as a string. *Usual mis-triage:* accepting it as "just phishing" without checking OAuth redirect URIs, server-side fetchers that follow redirects, and CSP path restrictions. In the scenario, an identity provider's prefix match turned a low into a high. Also: a marker inside a login redirect's return parameter, and a clean result produced by the scanner's own client.

8. SSRF through URL-fetch parameters. *Question:* did the server only fetch the scanner's host, or did it reach something the scanner cannot? *Strongest evidence:* a full response containing something specific to an internal service that could not have been guessed. For blind cases, a differential with known-open, known-closed and non-existent targets, each repeated. *Usual mis-triage:* escalating a link preview that fetches by design without testing internal reach, and trusting a clean result from canonical internal addresses only. The fix the post prefers is a connect-time address check, or resolve once and pin, re-checked on every redirect hop.

9. XXE: external entities. *Question:* was a DOCTYPE merely processed, or was an external reference resolved? *Strongest evidence:* file data carrying a value the scanner could not have known. For blind endpoints, a full HTTP callback from the application's egress, or file contents in an error. *Usual mis-triage:* parking a lone DNS lookup as "possible" when an attacker-hosted DTD then produced full HTTP and an error-based read; and trusting a clean in-band test. The post notes that none of the Python, libxml2-based or Node.js parsers it measured resolved an external general entity in its default configuration (lxml's default did load a local external parameter entity), that Java's defaults, which it did not test, are a notable exception to check, and that an expansion bomb should not be fired at a live service.

HTTP parsing and headers

10. CRLF and header injection. *Question:* did a carriage return or line feed create a distinct header or response, or did the value only reach a header? *Strongest evidence:* the raw bytes, with line endings visible, showing the injected header on its own line and parsing as a header. *Usual mis-triage:* a percent-encoded sequence inside a Location value read as a split; the scenario re-filed it as an open redirect candidate. Also a clean result where a downstream component decoded the value a second time. In the post's tests, Node core's serialiser threw ERR_INVALID_CHAR on a control character.

11. Host header injection. *Question:* did the application build something a second party receives from a client-supplied host? *Strongest evidence:* the received reset or verification email pointing at the canary, or a clean second request for a cache-busted copy returning it. *Usual mis-triage:* escalating display text and ignoring the reset form that reflected nothing. In the scenario, the reset form was the most serious finding, because trust-proxy was fully open and X-Forwarded-Host passed through the load balancer.

12. HTTP request smuggling. *Question:* is this parser leniency, a desync between two named components, or another connection's request affected? *Strongest evidence:* a request on a second connection receiving the response meant for the smuggled prefix, confirmed with a harmless 404 prefix, few attempts and permission. *Usual mis-triage:* a timeout that was the front end waiting for a body, and two error codes that were two rejections. On the clean side, paths whose handlers never read a body (CL.0) are worth checking explicitly when upstream connections are reused.

Policy the browser enforces

13. CORS misconfiguration. *Question:* which origin is granted a read of which response, with credentials? The browser enforces reading, not sending. *Strongest evidence:* a proof-of-concept page on a matching origin, in a real browser, reading an authenticated response. *Usual mis-triage:* rating * with credentials high, although a browser refuses that combination for credentialed reads; rating a reflected origin low because the unauthenticated response was a 401; and a clean result from one hostile origin.

17. CSRF, SameSite and tokens. *Question:* does a forged request succeed using a credential the browser attaches by itself? *Strongest evidence:* a forged request from a proof-of-concept page, in a named browser, that changes state on a test account. *Usual mis-triage:* a "missing token" finding on a form whose token travels in a header; a form with a token field whose handler checks it only when present; a JSON endpoint assumed immune although it parses a text/plain form body; and login CSRF dismissed because the session cookie is Lax.

Tokens and API surface

14. JWT validation. *Question:* did the server believe the token, or just answer? *Strongest evidence:* a forged token claiming a second real user that returns that user's data, or a cracked secret that reproduces the signature. *Usual mis-triage:* a 200 for alg: none on a public endpoint, rated above the weak secret that was the real critical; a logout finding parked in the backlog as low, which is a question about design and how long the token lives rather than about signature checking; and a clean result from one variant while aud was not verified.

18. GraphQL introspection and batching. *Question:* is the finding a configuration fact, or an impact in this schema? *Strongest evidence:* behaviour from a low-privilege and a second-account session, plus a count of operations per request. *Usual mis-triage:* treating "introspection disabled" as the fix, and closing batching because the gateway rate-limits. In the lab, ten HTTP requests under a ten-per-minute limiter carried a thousand password guesses. Also: closing "GET supported" because GET is "only used for queries", when a cross-site link ran a mutation over GET, and masking an error instead of fixing the injection behind it.

Reading discovery tool output

4. Nuclei template matches. *Question:* which conditions evaluated true, against which response, and what class of evidence do they carry? The classes are detection, version comparison, exposure and exploit confirmation. *Strongest evidence:* exploit-confirmation templates that match a computed marker, content the request lacked, or an out-of-band interaction with computed content. *Usual mis-triage:* acting on the template's name and severity, and not checking which matcher fired. Under the default OR conditions, a template can be satisfied by its weakest matcher.

5. ffuf content discovery. *Question:* does a resource exist behind this path, or did a response pass the filters? *Strongest evidence:* a 405 with Allow, which the post calls often the strongest status-only evidence in a discovery run, or a 401 with a challenge whose scheme and realm have been read. Anything else needs a baseline at the same depth and in the same form, with the bodies diffed. *Usual mis-triage:* reading a list of responses as a list of resources. Others include trusting the word column rather than the URL after auto-calibration, and forgetting that size, word and line filters are not tied to status and can remove a real page.

15. Hidden parameter discovery with Arjun. *Question:* does the application actually read this parameter, and what does it do? *Strongest evidence:* a value that changes behaviour where a junk name and a near-miss name do not, followed by a demonstration of what it exposes or skips. *Usual mis-triage:* names a filter blocks, reported as parameters; and clean results from the wrong body format or an unfinished run. A discovered parameter is an input, so it still needs the injection checks.

Files and objects

6. Path traversal. *Question:* did the path leave its directory, and is the sink a read, an include or a write? *Strongest evidence:* content with the target file's structure that the request did not contain, checked against the bare last component; or the out-and-back differential. *Usual mis-triage:* a signature served from the application's own file; an error message that disclosed the joined path dismissed as informational when it was the lead to the real finding; and a production proxy treated as the fix.

20. File upload. *Question:* which of accepted, stored, served and executed did the scanner observe? *Strongest evidence:* fetching the file and getting output only execution can produce. For SVG or HTML, loading it in a browser and checking which cookies the script can see. *Usual mis-triage:* a 200 on the upload escalated as code execution. Another is a double-extension bypass closed from the stock configuration: on the same Apache build with an AddHandler line, shell.php.jpg ran. A third is an SVG finding closed because of nosniff, although Chromium ran the script served as image/svg+xml with nosniff set.

21. Insecure deserialization. *Question:* which of accepted, parsed, instantiated and executed happened? *Strongest evidence:* an out-of-band callback with a token unique to the request, or a deserializer's own error for parsing. *Usual mis-triage:* a delay that came from a throttle on any unparseable session; an identical error response closed as noise while every code-running payload ran behind it; and a PHP finding closed as "no gadget". A negative is about the scanner's gadget list, not the application.

A suggested reading order

If you are holding a finding, go straight to its post. Each one ends with a triage checklist and a worked resolution of its scenario.

If you are building a triage process, read in this order:

  1. SQL injection. It sets out error, boolean, time, UNION and out-of-band evidence in the most detail, and later posts reuse its controls.
  2. OS command injection. Computed markers, the difference between DNS and HTTP callbacks, and asynchronous sinks.
  3. Reflected XSS. Reflection versus execution, and why the context decides.
  4. Nuclei and ffuf. Reading tool output, catch-all responses, and how a clean run misses.
  5. The group that matches your application. Choose from the URL-handling posts (open redirect, SSRF, XXE), the HTTP posts (CRLF, Host header, smuggling), the browser-policy posts (CORS, CSRF), the token and API posts (JWT, GraphQL, Arjun) or the file and object posts (path traversal, file upload, deserialization).
  6. Why "the scan passed" is not "the scan ran". Read it before you close anything as clean.

Where AppSecD fits

AppSecD's dynamic and API testing runs Nuclei, Dalfox, SQLMap, Commix, Katana, Arjun, FFuf and Interactsh for out-of-band detection, plus 150+ native checks and API discovery across 50+ web frameworks. That line, and the shorter mentions of dynamic testing elsewhere in data/products.ts, are what that file says about it. This guide makes no claim about how AppSecD runs any of those tools, which checks it applies or how it rates a finding. The confirmation model, the evidence classes and the checklists in the series are general practice that applies to any scanner's output, ours included.

The scenarios summarised in this post are hypothetical and do not describe any deployment, user or finding.

More about AppSecD · All posts