DedSec Security Research ·
Here is a hypothetical. A dynamic scan of a staging environment returns three findings. The first, titled "Server-side request forgery" and rated high, is on /api/preview?url=. The scanner sent a URL on a host it controls, its listener received a GET from the application's egress address, and the preview the application returned contained the title of the scanner's page. The second, titled "Possible blind SSRF" and rated medium, is on /hooks/test?url=. Every response was the same 202, but requests aimed at some internal addresses came back in milliseconds and others took several seconds. The third is on /import?url=, which the scanner reported clean: its payloads, http://127.0.0.1/, http://localhost/ and http://169.254.169.254/, were all refused with "URL not allowed".
The first finding gets escalated, because high is high. The second is parked, because "possible" sounds like a guess. The third is never looked at. All three calls are probably wrong. As in the earlier posts in this series, each rests on the title and the rating rather than on what the scanner observed and what that observation can prove.
This post is for whoever is holding a server-side request forgery finding from a dynamic scan, or a clean result on a URL-fetch parameter that they are about to rely on. It covers what CWE-918 is and the two-part claim a finding has to support, what full-response, differential and out-of-band evidence each prove, the many spellings of an internal address and which HTTP clients connect to each one, what Python's ipaddress module says about IPv4-mapped and transition addresses, four common URL filters and what got past each one, DNS rebinding between the check and the connection, redirects and URL schemes, the false positives, two fixes tested against the same inputs, and a triage checklist. It is the eighth post in a series about confirming DAST findings, after reflected XSS, SQL injection, OS command injection, Nuclei template matches, ffuf content discovery, path traversal and open redirect. Blind SSRF detected through callbacks is covered in out-of-band testing and blind SSRF, and this post does not repeat it. The open redirect post covers where URL parsers disagree about userinfo and backslashes, and how SSRF filters are bypassed by following a redirect. This post refers back to both rather than repeating them.
Sources, and how each was checked. The passages quoted verbatim below were read on our test machine on 31 October 2026: the source of Python's ipaddress module, read with the inspect module; the Debian changelog that ships with Ubuntu's Python 3.12 package; and the curl 8.5.0 manual page. The error messages quoted are the ones the clients printed. CWE-918 (server-side request forgery), RFC 3986 (URI syntax), RFC 4291 (IPv6 addressing, including IPv4-mapped and the deprecated IPv4-compatible forms), RFC 6052 (the NAT64 well-known prefix), RFC 3056 (6to4), RFC 6598 (the shared address space 100.64.0.0/10), RFC 6874 (zone identifiers in URIs), the IANA special-purpose address registries and the WHATWG URL Standard are cited by name or number and described in our own words, because we had no copy of them on the machine to quote from.
The measurements were made the same day in a scratch directory on an Ubuntu 24.04 machine, inside a Linux network namespace with only a loopback interface. The software was curl 8.5.0, Python 3.12.3 (Ubuntu package 3.12.3-1ubuntu0.17) with requests 2.31.0 and urllib3 2.0.7, and Node.js 22.22.2. Inside the namespace we assigned four extra addresses to the loopback interface (the fourth, 127.0.0.20, for the DNS server below) and ran small HTTP listeners on five addresses. 127.0.0.1 and [::1] stood in for services on the server itself, as two separate listeners. 10.0.0.5 stood in for a private internal host. 169.254.169.254 stood in for a link-local service. It answered with our own text: it is not a cloud metadata service, and we did not test one. 11.0.0.2, an address from a publicly routed range, stood in for the attacker and the open internet, so that a check for "globally reachable" would treat it as the outside world. Packets to it never left the machine. Every internal listener answered with a random value generated when the lab started, so that a response could be shown to contain something the requester could not have known. A private hosts file mapped attacker.test to 11.0.0.2, internal.test to 10.0.0.5, and localtest.attacker.test to 127.0.0.1. A short DNS server of our own, on 127.0.0.20, served the names used for the rebinding tests. Nothing was downloaded, and nothing outside the namespace was contacted. We did not measure browsers, any cloud provider, Java, Go, PHP or any particular framework. Where this post says something about them, it says so. The opening scenario is hypothetical, and no number in this post measures any scanner, ours included.
CWE-918 covers a server that receives a URL, or part of one, from input it does not control and fetches it without making sure the request goes where it should. Common shapes include parameters named url, uri, src, feed, webhook, callback, image, avatar, import or target, feeding a link preview, a webhook sender, an image or PDF renderer, a feed importer or an "import from URL" button.
The weakness is not that the server fetches a URL. Many applications exist to do exactly that. The weakness is that the attacker gets to borrow the server's position on the network. So the claim a finding has to support has two halves, and a scanner often proves only the first:
A link previewer that fetches any public URL meets the first half by design. The finding is the second half. Without it there is an outbound request feature, which is worth recording but is not a vulnerability. Severity then depends on two more facts: what is reachable, and how much of the response comes back.
The response comes back. The application returns the fetched body, or enough of it: a preview card, an imported document, an error page that quotes the upstream response. This is the strongest evidence, and the content decides how much it proves. If the returned content came from the scanner's own host, it proves only the first half. If it came from an internal address, and contains something the scanner could not have known in advance, it proves both halves. In our lab, every internal listener answered with a random value. A response carrying that value is proof of reach, because the only way to get the value was to reach the listener. On a real system the equivalent is content that is specific to the internal service, such as a version banner, a service's own identifier or a page title. A generic "200 OK" is not enough, because a catch-all error page returns one too.
A difference comes back. The response does not contain the fetched body, but something about it varies with what the server reached. We built a lab application with two routes. /status returned only the outcome of the server's fetch: the status code, or the name of the exception class. /blind fetched the URL in the same way and always answered 202 "queued". We pointed both at six targets, three times each:
status=200. Both routes took 2 to 4 milliseconds.error=ConnectionError. Both took about 2 ms.error=ConnectionError, the same class as the closed port, because our application printed only the class name. Both took about 2 ms.error=ReadTimeout. Both took 3.0 seconds, which is the fetcher's own timeout.error=ConnectTimeout. Both took 3.0 seconds.error=ConnectionError. Both took 1.5 seconds.The three repeats for each target agreed to within a few milliseconds. So /status is a port scanner with labels. It separates open, closed or non-existent, unresponsive and filtered. /blind separates only three groups by time: fast, which covers open, closed and non-existent alike; the fetcher's timeout; and the target's own idle timeout. On loopback, timing could not tell an open HTTP port from a closed one. What a timing differential measures is the client's timeout and the target's behaviour, not "port state" as such. We measured loopback only. On a real network, latency adds noise that loopback does not have.
A differential proves the first half and some of the second. The server connects to addresses and ports the attacker chooses, and the attacker learns which of them answer. That is network reconnaissance from inside the perimeter. It is not proof that response content can be read. To support it, the evidence needs controls sent in the same session: a known-closed port, a non-existent name and a known-open port, each repeated, with the difference stated in terms of those controls.
A callback arrives. The scanner's listener receives a DNS query or an HTTP request. This proves the first half, if the source and timing hold up. The out-of-band post covers how that correlation works and why a DNS-only callback is weaker evidence than an HTTP one. A callback says nothing about the second half. The server reached the internet, which is where the scanner's listener is. Whether it can also reach inside is a separate test.
One measured detail belongs here because it changes how a DNS-only callback reads. One of the filters below resolves the host name in order to check it. Our DNS server logged the query for a name even when that filter then refused to fetch it. The validator made the lookup, not the fetcher. A DNS callback from an application with that kind of filter proves only that the filter ran.
The bypasses below are not clever. They are inputs where the filter and the HTTP client disagree about which address a string names. We wrote 32 URLs that each name a lab listener or the attacker host, and recorded three things for each: what Python's urllib.parse.urlsplit reported as the host name, whether ipaddress.ip_address accepted that host name, and where four clients actually connected. The clients were requests, urllib.request, curl and Node.js's fetch.
Short, decimal, hex and octal IPv4. 127.1, 127.0.1, 2130706433, 0x7f000001, 0x7f.0.0.1, 0177.0.0.1, 017700000001 and 127.000.000.001 all connected to the 127.0.0.1 listener, in all four clients. The same forms of 10.0.0.5 (0xa.0.0.5) and of 169.254.169.254 (0xa9fea9fe, 2852039166) reached those listeners too. In Python, urlsplit returned each of these as text, unchanged. ipaddress.ip_address raised ValueError on every one of them, including 127.000.000.001. IPv4Address gave the reason for that one, in a message that began "Leading zeros are not permitted". socket.inet_aton and socket.getaddrinfo turned every one into the canonical address. Python therefore has two different answers to "is this an IP address?", and the HTTP clients use the permissive one. Node.js's URL class, which follows the WHATWG URL Standard, normalised every one of them to the canonical address while parsing. That means a check written against new URL(value).hostname in Node.js sees 127.0.0.1.
Zero and the unspecified addresses. http://0/ and http://0.0.0.0/ reached the 127.0.0.1 listener in all four clients. http://[::]/ reached the [::1] listener. On Linux, connecting to the unspecified address reaches the local machine. A denylist that lists 127.0.0.0/8 and ::1 but not these misses them.
IPv4-mapped IPv6. RFC 4291 defines ::ffff:0:0/96 as IPv4 addresses written in IPv6 form. [::ffff:127.0.0.1], [::ffff:7f00:1] and [0:0:0:0:0:ffff:127.0.0.1] all reached the IPv4 127.0.0.1 listener, in all four clients. [::ffff:169.254.169.254] reached the link-local stand-in. The operating system carried the connection over IPv4. A filter that decides by address family, or by an IPv4 range list, does not see an IPv4 address here at all.
IPv4-compatible IPv6. [::127.0.0.1] is the older form that RFC 4291 deprecates. All four clients failed with "network unreachable", or curl's "Couldn't connect to server". Linux did not route it to IPv4. Keep it in mind for the next section, because Python classifies it in a surprising way.
Non-ASCII digits. http://127.0.0.1/ uses full-width digits and full stops, and http://127。0。0。1/ uses the ideographic full stop. Node.js's URL class normalised both to 127.0.0.1, and fetch reached the listener. curl reached it too. requests refused to parse them ("Failed to parse"), and urllib.request raised UnicodeEncodeError. Python's socket.getaddrinfo, given the host name that urlsplit returned, resolved both to 127.0.0.1, because Python encodes host names with its idna codec. On our machine, '127.0.0.1'.encode('idna') returned b'127.0.0.1'. In a Python service that checks the string and then fetches with curl or a Node.js worker, the check sees full-width digits and the fetch goes to loopback.
Names. localhost and LOCALHOST reached loopback in every client. There was one difference. Our hosts file mapped localhost to 127.0.0.1 only, and requests, urllib.request and fetch connected there. curl connected to the [::1] listener instead, so curl did not take its answer for localhost from our hosts file. A denylist that blocks 127.0.0.0/8 but not ::1 is bypassed when the fetcher is curl. internal.test reached 10.0.0.5. The name that matters most is localtest.attacker.test. It reached 127.0.0.1, because the attacker controls that name's DNS and pointed it at loopback. Any denylist that checks the string the user sent, rather than the address the name resolves to, cannot catch this. Public DNS services that resolve any name to an address embedded in it exist for testing, so the attacker does not even need a domain. We did not contact one.
Trailing dots. A trailing dot marks a fully qualified name. In our lab, localhost. and internal.test. failed to resolve, probably because the C library's hosts-file lookup did not match them. We did not investigate further, so treat it as an artefact of our hosts file. dnsinternal.test., a name served by our DNS server, resolved with or without the dot, to 10.0.0.5. A string comparison against dnsinternal.test does not match dnsinternal.test..
Zone identifiers. RFC 6874 writes an IPv6 zone in a URI as %25 followed by the zone name. For http://[fe80::1%25lo]/, Node.js's URL class threw ERR_INVALID_URL. Python's urlsplit returned fe80::1%25lo, and ipaddress read the scope ID as 25lo, without percent-decoding it. curl took the zone and attempted a connection to fe80::1 with the zone lo, which failed only because nothing was listening. Python still classified the address as link-local, so this is a parser disagreement rather than a filter bypass in our tests. It belongs in the same category as the userinfo and backslash cases in the open redirect post: inputs on which the checker and the fetcher read different things.
The rule follows from the list. Do not decide anything from the string. Resolve the host name the same way the fetcher will, and check the address that comes back.
Checking the address is the right idea. The obvious tool in Python is the ipaddress module, and its properties have edges. We printed six properties for 20 addresses on this machine:
The source explains the mapped-address split. In this build, IPv6Address.is_loopback is:
return self._ip == 1So only ::1 counts as loopback. is_private, by contrast, checks the mapped address first. Its docstring says that for IPv4-mapped addresses "the following condition holds", followed by address.is_private == address.ipv4_mapped.is_private, and is_global is defined as not self.is_private. A filter written as ip.is_loopback or ip.is_link_local lets ::ffff:127.0.0.1 through, while a filter written as not ip.is_global stops it. As the measurements above show, connecting to ::ffff:127.0.0.1 reaches the IPv4 loopback listener.
There is a second, less obvious edge. These answers depend on the patch level, not just the version number. The changelog shipped with this machine's Python package records a backported patch under the heading "SECURITY UPDATE: is_private and is_global mismatch". The patch is described as a fix for "private" (non-global) IP address ranges in Lib/ipaddress.py, its documentation and its tests, for CVE-2024-4032. Two machines that both report Python 3.12.3 can therefore give different answers for some ranges. We measured only this build. A filter that relies on these properties should be tested on the interpreter that runs it in production, with the addresses in the list above.
What held in our tests: unwrap ipv4_mapped first, decide on is_global rather than is_private, and explicitly reject ::/96, 64:ff9b::/96, 64:ff9b:1::/48 and 2002::/16, the IPv4-compatible, NAT64 and 6to4 prefixes. The fixed filter below does exactly that.
Node.js has its own version of the problem. Its net.BlockList treated a rule for 127.0.0.0/8, added as IPv4, as matching ::ffff:127.0.0.1 checked as IPv6, which is the behaviour you want. It did not match ::127.0.0.1. And a rule for ::ffff:0:0/96, which looks like a sensible way to block mapped addresses, also matched the plain IPv4 address 11.0.0.2. Our first Node.js fix contained that rule and refused the attacker stand-in along with every other name it resolved. It is a failure in the safe direction, but it shows that a rule set should be tested against an address it is supposed to allow.
We ran four common filters over 38 inputs: the 32 spellings above, two redirects from the attacker host to internal destinations, one redirect from the attacker host to itself, the DNS-served name with and without the trailing dot, and a mapped address with an explicit port. Each filter was a Python function. If it passed a URL, the URL was fetched with requests, which follows redirects by default. With no filter at all, 31 of the 38 inputs reached an internal listener through requests.
0, [::], the mapped addresses, every name other than localhost, and both redirects.::ffff:127.0.0.1 is not is_loopback, as above.0.0.0.0 and [::]. Everything that ip_address could not parse was still allowed as a name: the short, decimal, hex and octal forms, 0, localhost, and every DNS name.[::127.0.0.1], which ipaddress calls global, and that request failed only because Linux would not route it. Without a translator or a route, that input fails at the network rather than at the filter. With redirects turned off (allow_redirects=False), it let nothing through to an internal listener. In our harness the 302 came back to the caller. In a real application, what happens next depends on whether anything follows that Location.F4 looks like the answer. In the run above, it is. The next section is about the run where it is not.
F4 resolves the host name to check it, and then hands the URL to requests, which resolves the name again to connect. Two lookups means two answers, and the attacker controls the name's DNS.
We tested this with our lab DNS server. The first A query for a name returned 11.0.0.2, the attacker stand-in, which is global. Every later query returned 127.0.0.1, with a time-to-live of zero. Then we ran F4 on http://rb1.test/. The DNS server's log reads, in order:
rb1.test A #1 -> 11.0.0.2rb1.test A #2 -> 127.0.0.1The check passed on the first answer, and requests connected on the second. The response came from the internal 127.0.0.1 listener. The same pattern in Node.js gave the same result: a dns.lookup to check, then fetch. The check saw 11.0.0.2, and fetch reached 127.0.0.1. This is DNS rebinding applied to a server-side check. The time between check and use was a few milliseconds, and that was enough, because nothing in our namespace cached the first answer.
How easily this works elsewhere depends on caching, which we did not measure. A local caching resolver, a resolver that enforces a minimum time-to-live, or a runtime that caches lookups would make the second answer equal the first, and the attack less reliable. The variant in which a name returns two addresses at once, one global and one internal, depends on which address the client tries first. We did not test it. Neither is a fix you can rely on. The fix is to make sure there is only one lookup, or that the check runs on the address the socket actually connects to.
Redirects. The open redirect post measured a fetcher that checked the first URL and then followed a redirect into the internal network, and found that urllib.request, requests and fetch all follow redirects by default, while curl follows them only with -L. The result here is the same: F1 to F4 all passed http://attacker.test/redir?to=http://127.0.0.1/ and returned the internal response. The attacker does not need an open redirect on your domain. Any host they control can redirect. A check that runs once, before the first request, is a check of the first hop only.
Schemes. Which schemes a fetcher accepts decides what an SSRF can do besides read HTTP. We gave each client a file URL and two non-HTTP schemes aimed at our raw TCP listener on 127.0.0.1:6379:
curl -V lists dict, file, gopher, ldap, smtp and others among its protocols, read file:///etc/hostname and returned the machine's host name.gopher://127.0.0.1:6379/_PING%0D%0ASET%20labkey%20x%0D%0A to the listener, which received the bytes PING\r\nSET labkey x\r\n followed by a final CRLF. Gopher in curl writes an attacker-chosen byte string to any TCP port. That is how an SSRF that accepts any scheme becomes a way to send commands to an internal service that speaks a line-based protocol.dict://127.0.0.1:6379/INFO, and the listener received CLIENT libcurl 8.5.0\r\nINFO\r\nQUIT\r\n.--proto =http,https, curl refused both: 'Protocol "gopher" not supported or disabled in libcurl', and the same for file. The manual page describes = as meaning "Permit only this protocol (ignoring the list already permitted)", and says unknown and disabled protocols in the list produce only a warning, so a script can name protocols to disable whether or not curl was built with them. A service that runs curl, or links libcurl, should restrict protocols for the first request as well as for redirects.file:///etc/hostname without complaint. Given directly rather than through a redirect, file is an ordinary scheme to it. As the open redirect post measured, its redirect handler refuses anything other than http, https or ftp.Even plain http to a non-HTTP port sends something. Our raw listener received requests's whole request line and headers, and the 1.5 second differential above was that listener waiting for more before it gave up.
And the false negatives, which matter more because they produce no finding to triage: payloads limited to canonical 127.0.0.1 and 169.254.169.254, refused by a string filter that 0x7f000001 or [::ffff:127.0.0.1] would have got through; internal addresses that were tested but had no listener, so there was no difference to see; fetches done asynchronously after the response was sent, which no timing difference can reveal; egress filtering that blocks the callback but not internal requests; and URL fields behind authentication or a multi-step flow that the scan never reached. The scan-passed post covers that last case across a whole scan.
The procedure below is general practice. Point every request either at a listener you control or at an internal destination that is explicitly in scope. Read, never write. The point is to prove reach, not to use it.
127.1, decimal, hex, octal, 0, [::], [::ffff:127.0.0.1], a name you control that resolves to the target, and a redirect from a host you control. Record which one passed. That tells you which kind of filter is in place: string, literal-only, or resolve-then-check.All of this is general practice. We tested two versions of the core fix against the same 38 inputs, plus fresh rebinding names.
Python: resolve once, check, pin the address, re-check every hop. The function rejects any URL that is not ASCII or that contains whitespace, a control character or a backslash. It requires scheme http, with no user name or password. It resolves the host name once with getaddrinfo and unwraps any IPv4-mapped address. It rejects the ::/96, 64:ff9b::/96, 64:ff9b:1::/48 and 2002::/16 prefixes, and requires every address to be is_global. Then it connects to the resolved address itself, with http.client, and sends the original host name in the Host header. It does not follow redirects on its own. For a 3xx response, it resolves the Location against the current URL and runs the whole check again, up to three hops. Result: none of the 38 inputs reached an internal listener. http://attacker.test/ and the redirect from the attacker host to itself were fetched from 11.0.0.2. Both inward redirects were refused at the second hop. On a fresh rebinding name, the DNS server logged one A query, and the response came from 11.0.0.2, the address that had been checked. The second answer was never asked for.
Two limits. Our lab was plain HTTP. Pinning an address for HTTPS means connecting to the IP while still sending the original name for SNI and verifying the certificate against it, which this test does not cover. And rejecting non-ASCII hosts also rejects internationalised domain names, which is a product decision.
Node.js: check the address inside the connection's own lookup. http.get accepts a lookup option, which is called to resolve the host name for the socket that is about to connect. Our version resolved with dns.lookup and refused if any address matched a net.BlockList of the private, loopback, link-local, documentation and transition ranges. Because the check runs on the address the socket connects to, there is no second lookup to rebind. On a fresh rebinding name, the DNS server logged one query, and the response came from 11.0.0.2. The http module does not follow redirects, so the inward redirects came back as 302s and went no further.
The first version of this fix let 25 inputs reach an internal listener, every one of them an IP literal: 127.0.0.1, all the numeric spellings, [::1], [::], the mapped addresses, 10.0.0.5, the link-local addresses and the two non-ASCII forms, which Node.js's URL class had already turned into 127.0.0.1. A minimal test confirmed the cause. For http://127.0.0.1:9/, the lookup function was never called. When the host is already an address, there is nothing to look up. The second version also checks the host against the BlockList whenever net.isIP says it is an address. With that change, none of the 38 inputs reached an internal listener. The lesson is not specific to Node.js. A hook on name resolution covers names only, so make sure something checks literals as well.
Around the fix:
--proto =http,https for curl, and the equivalent protocol options in libcurl.Static analysis models SSRF as taint from a request value to an HTTP client sink: requests.get, urlopen, fetch, an http.request call, or a curl handle. The SAST false positive post covers the general failure of crediting a sanitiser against a sink it does not protect. SSRF is a clean example, because the sanitiser and the sink look at different things.
A rule that credits a function named is_safe_url, or a urlsplit followed by a comparison, would mark all four as safe. This is where a reviewer has to look at the client call, not just at the check. A confirmed DAST finding tells you that a reachable request made the server fetch an internal destination, but not which line chose the client or skipped the check. A SAST finding tells you which line passes request data to a fetch, but not whether a deployed route reaches it or whether a network control stops it. Each answers the other's open question.
127.0.0.1 and 169.254.169.254, the filter has not been tested. Retry with the spellings in the confirmation procedure.Back to the three hypothetical findings.
In the scenario, the /api/preview?url= finding was the feature. The scanner's evidence proved only the first half: the server fetched the scanner's page, which is what a link preview does. The second half was then tested. The preview service resolved each host name once, checked the address, connected to that address, and checked every redirect hop again. Canonical, numeric and mapped loopback addresses, a name resolving to loopback, a rebinding name and an inward redirect were all refused. The finding was closed as "outbound fetch by design, internal reach tested and refused", with the requests attached, and the rating dropped from high to informational.
In the scenario, the /hooks/test?url= finding was real. Retested with controls, a known-closed port and a non-existent name returned in about the same time as an open port, and a filtered range hit the fetcher's timeout every time. The webhook tester could be used to map which internal hosts and ports answered. No response content came back, so the finding was confirmed as semi-blind SSRF with a reachability oracle. The webhook test was moved behind a connect-time address check, with egress from its host restricted at the network layer.
In the scenario, the /import?url= clean result was a false negative. The filter was a string denylist, F1 above. http://0x7f000001:8080/ reached an admin listener on the import host itself, and so did http://[::ffff:127.0.0.1]:8080/ and a test name resolving to 127.0.0.1. The fix replaced the denylist with a resolve-once, pin-the-address fetch that checks every hop again, and the retest used the whole spelling list.
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. In its lifecycle this is the runtime stage: DAST and API testing run against the deployed application, because code review cannot see what only appears once the application is assembled and running. Its static analysis includes dataflow taint analysis that traces source to sink across functions. Its AI layer assembles attack chains across findings, showing how separately unremarkable issues combine. Its findings are deduplicated across scans and tracked through new, reopened and fixed states, and its lifecycle supports maker-checker approval, so a finding marked as a false positive can require a second person to confirm it.
That is the whole claim. This post does not claim whether AppSecD has a dedicated SSRF check, whether its Interactsh out-of-band detection is applied to URL-fetch parameters, which payloads, address spellings, rebinding names or schemes it sends, whether it uses response, status or timing differentials, how it correlates or weighs a callback, whether it checks the source address of an interaction, how it rates the severity of an SSRF finding, whether its attack-chain assembly links SSRF to other findings, whether its static rules treat any particular check as a sanitiser for HTTP client sinks, or how accurate its SSRF detection is. The measurements, the confirmation procedure, the fixes and the checklist above are general practice, not a description of how AppSecD works internally, and they apply to any scanner's output, ours included. The scenario in this post is hypothetical and does not describe any AppSecD deployment, user or finding.