DedSec Security Research ·
Here is a hypothetical. A dynamic scan of a staging environment returns three findings. The first, titled "Open redirect" and rated low, is on /out?url=. The scanner sent https://marker.example/ and the response was a 302 with Location: https://marker.example/. The second, also titled "Open redirect" but rated medium, is on /account/settings?return=. The scanner sent the same marker and found it in the Location header of a 302. The third is on /continue?to=, which the scanner tested and reported clean: its payloads were refused with a 400, and the one redirect it did get, for /\marker.example/, landed back on the application when the scanner's HTTP client followed it.
The first finding is accepted as a risk, because an open redirect is "just phishing". The second is assigned to a developer, because medium is higher than low. The third is never looked at, because nothing was found. 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 an open redirect finding from a dynamic scan, or a clean result they are about to rely on. It covers what CWE-601 is and the claim a finding has to support, the three places a redirect can live and which of them a scanner can see, what counts as confirmation, the inputs on which URL parsers disagree about where a URL points, why the scanner's own HTTP client changes the answer, the allowlist checks that fail and the ones that hold, why an allowlisted destination can still be a problem, how to frame the impact honestly, the false positives, and the fix. It is the seventh post in a series about confirming DAST findings, after reflected XSS, SQL injection, OS command injection, Nuclei template matches, ffuf content discovery and path traversal. It refers back to which security headers matter for the CSP part of the story and to out-of-band testing and blind SSRF for the server-side part.
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 urllib.parse and urllib.request modules, read with the inspect module, and the curl 8.5.0 manual page. The error messages quoted are the ones the clients printed. CWE-601 (URL redirection to an untrusted site), RFC 3986 (URI syntax), the WHATWG URL Standard, RFC 9110 (HTTP semantics), RFC 6749 (OAuth 2.0) and RFC 9700 (the OAuth 2.0 security best current practice) 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 scratch directories on an Ubuntu 24.04 machine, inside a Linux network namespace with only a loopback interface and a private hosts file that mapped three names to three loopback addresses: trusted.test to 127.0.0.1, evil.test to 127.0.0.2 and internal.test to 127.0.0.3. The software was curl 8.5.0, Python 3.12.3 with the requests library 2.31.0, and Node.js 22.22.2, whose URL class and built-in fetch implement the WHATWG URL Standard that browsers also follow. We wrote a small test application on a raw socket so that each Location header went out byte for byte as we chose it, plus a stand-in attacker host and a stand-in internal service. Nothing outside 127.0.0.1 to 127.0.0.3 was contacted. We had no browser on the machine. Where this post says what a browser does, it is reasoning from the WHATWG parser in Node.js or from the standards, not a browser measurement, and it says so. In the parsing results, evil.example and trusted.example are plain strings and were never resolved. The opening scenario is hypothetical, and no number in this post measures any scanner, ours included.
CWE-601 covers an application that takes a URL, or part of one, from input it does not control and redirects the user to it without checking that the destination is one it intended. The classic shape is a parameter named next, return, returnUrl, redirect, url, continue, goto or dest that ends up in a Location header. The weakness is not the redirect. Applications redirect all the time. The weakness is that the application lets someone else choose where its redirect goes.
Two kinds of victim are possible, and they give different findings.
So the claim a finding has to support is narrow and checkable: input to this request changes the origin that the client ends up at, and the attacker can make it an origin they control. "The marker appears in the Location header" is evidence towards that claim. It is not the claim itself.
A redirect can be issued in three different layers, and a dynamic scanner that reads HTTP responses sees them very differently.
A 3xx response with a Location header. This is the visible case. The server decides where the client goes, and the decision is in a response header. RFC 9110 defines the Location value as a URI reference, which means it may be relative, and the client resolves it against the URL of the request that produced it. That resolution step is the source of most of the trouble in this post. A Refresh response header, which is not defined by HTTP's own specifications, is described as working the same way with a delay. We did not test a client that honours it.
An HTML meta refresh. The response is a 200 with <meta http-equiv="refresh" content="0;url=..."> in the page. Our /meta route reflected the parameter into that tag. Neither client we tried followed it: curl -L and Node.js's fetch both stopped at the 200 on trusted.test, and the stand-in attacker host received nothing. Per the HTML Standard a browser would follow it; we did not test one. A scanner has to parse the HTML to find it, and then has to work out the URL from the content attribute, where the syntax is looser than in a Location header. We did not measure how browsers parse that attribute.
A JavaScript navigation sink. location = value, location.href = value, location.assign(value), location.replace(value) and window.open(value) all navigate. Our /js route reads its to parameter in the browser, from location.search, and assigns it to location. The server's response was the same 200 page whatever the parameter held. The value //evil.test/j did not appear anywhere in the response body, and no HTTP client went anywhere. This is DOM-based open redirect. A request-and-response diff cannot see it, for the same reason it cannot see DOM-based XSS, which the XSS post covers. Finding it needs a browser that runs the page and watches where it navigates, or static analysis of the page's JavaScript that traces location.search, location.hash or postMessage data to a navigation sink.
The JavaScript sinks also carry an extra risk that a Location header does not. Assigning javascript:... to location runs that script in the page's origin, which makes it cross-site scripting rather than a redirect. We could not measure a browser. We did measure the parsing half of a well-known trick. Node.js's URL class parsed javascript://trusted.example/%0aglobalThis.ran=1 as protocol javascript: with host trusted.example, so a check that asks "is the host ours?" passes. Percent-decoded, as a javascript: URL's body is before it runs, the body became //trusted.example/ followed by a newline and globalThis.ran=1. The first line is a JavaScript comment. Evaluated in Node.js's vm module, the second line ran and set ran to 1. A host check without a scheme check therefore lets script through to a client-side sink. In a Location header, by contrast, our clients refused javascript: outright, as the table below shows. As far as we know browsers also refuse to run script from a redirect, but we did not measure that.
A scanner that tests for open redirect usually sends a URL on a host it owns, often a unique one, and then looks at the response. The finding stands or falls on one step: resolve the Location value against the request URL, with the same parser a browser uses, and compare the resulting origin with the marker's. If they match, the destination is attacker-chosen. If the resolved host is the application's own, the payload was reflected but the redirect was not open.
Three of our lab routes show why the string match is not enough.
to=https://evil.test/ with Location: /home?next=https%3A%2F%2Fevil.test%2F. The marker is in the header. The header resolves to trusted.test, and every client ended on trusted.test. A matcher that looks for "evil.test" in the Location header fires here. A matcher that resolves the header and compares hosts does not.to=evil.test with Location: /evil.test. Same result: a same-origin path that happens to contain the marker's name.Location: /login?return=%2Faccount%3Fto%3D%252F%252Fevil.test%252Fa. The marker is in there, double-encoded, and it is a redirect to the login page. With the session cookie set, the same request returned Location: //evil.test/a, which is open. The unauthenticated scan had not tested the handler at all. It had tested the login redirect. The scan-passed post covers how that happens across a whole scan.The marker host matters too. A scanner that sends https://evil.example/ and then sees a Location containing evil.example cannot tell whether it is looking at the host or at a path segment. A unique, random host name, compared against the resolved host and not searched for as a substring, removes that ambiguity. Following the redirect and recording where the client lands is a cross-check, not a substitute, for the reason in the next two sections: the client's parser has to be the browser's parser, and most HTTP libraries do not use it.
Many open redirect bypasses are not clever. They are inputs on which the application's check and the browser disagree about which host a string names. The application usually checks with its language's URL library. The browser uses the WHATWG URL Standard, which describes what browsers actually do and deliberately accepts inputs that RFC 3986 treats differently. We parsed the same inputs with Python 3.12.3's urllib.parse.urlsplit and urljoin and with Node.js 22.22.2's new URL(value, base), using https://trusted.example/login as the base, which is what a Location header is resolved against.
Scheme-relative URLs. //evil.example/x is what RFC 3986 calls a network-path reference: it keeps the current scheme and replaces everything else. Both parsers agreed it names evil.example. This is the most common bypass of a check that only asks whether the value "starts with a slash".
Backslashes. In the WHATWG standard, for the special schemes, which include http and https, a backslash is treated as a slash. /\evil.example/x, \/evil.example/x and \\evil.example/x all resolved to evil.example in Node.js. Python's urlsplit treated all three as a path with no host, and urljoin kept them on trusted.example. A check written in Python that says "it starts with / and not with //, so it is a local path" passes /\evil.example/, and a browser following the WHATWG rules goes to evil.example.
Extra slashes. ///evil.example and https:///evil.example resolved to evil.example in Node.js, which skipped the extra slash and read the next segment as the host. Python's urlsplit gave an empty network location and a path of /evil.example, so urljoin landed on https://trusted.example/evil.example.
A scheme with no slashes. https:evil.example, resolved against an https base, stayed on trusted.example in both parsers. WHATWG treats a same-scheme URL without slashes as relative, so it became the path /evil.example. Change the scheme and the answer changes. http:evil.example against the https base resolved to http://evil.example/ in Node.js, a different scheme and a different host. Python's urljoin returned http:evil.example unchanged, with no host at all. Parsed without a base, both forms named evil.example in Node.js. Whether a Location value like this is open therefore depends on the scheme of the page that issued it.
Userinfo. RFC 3986 allows user:password@ before the host. https://[email protected]/ names evil.example in both parsers. trusted.example is the user name. This is the bypass for checks that test whether the URL starts with the trusted origin.
Backslash before the @. This is where the two parsers pointed in opposite directions. For https://trusted.example\@evil.example/, Python reported hostname evil.example, because it splits the network location at the last @. Node.js reported host trusted.example and path /@evil.example/, because the backslash ended the authority before the @ was reached. Swap the names and the result swaps too. For https://evil.example\@trusted.example/, Python reported trusted.example and Node.js reported evil.example. A Python check that compares the hostname exactly, which is the right idea, accepts this value, and a browser following WHATWG goes to evil.example.
Characters that end the authority. https://evil.example#@trusted.example/ and https://[email protected]/ named evil.example in both parsers, because # and ? end the host before the @. Percent-encoded, https://evil.example%[email protected] named trusted.example in both, with evil.example%23 as the user name. These are aimed at hand-written checks that split on @ or search for the trusted name.
Tabs, newlines and leading spaces. The WHATWG standard removes ASCII tab and newline characters from anywhere in the input, and strips leading and trailing control characters and spaces. Python 3.12.3 does much the same. Its urllib.parse source defines _UNSAFE_URL_BYTES_TO_REMOVE = ['\t', '\r', '\n'] and strips _WHATWG_C0_CONTROL_OR_SPACE from the left of the URL. So / followed by a tab and /evil.example became //evil.example in both parsers, and so did the same with a newline, and a leading space before //evil.example. ht plus a tab plus tps://evil.example became an https URL to evil.example, and java plus a tab plus script:alert(1) was reported by urlsplit as scheme javascript. The danger is a check that runs on the raw string while the parser runs on the cleaned one. startswith('//') is false for slash-tab-slash, and the result is still a scheme-relative URL.
Numeric hosts. Node.js normalised https://0x7f.1/ and https://2130706433/ to https://127.0.0.1/. Python's urlsplit kept 0x7f.1 and 2130706433 as text. That does not matter for phishing. It matters a great deal for SSRF filters, below.
Nothing in this list is necessarily a bug. The libraries follow different rules, and the rules differ. The rule that follows is about consistency: the code that checks a URL must use the same parser as the code that acts on it, and for a redirect that a browser follows, the code that acts on it is the browser.
A scanner, or a tester with a command line, often confirms a redirect by following it. Following it with a client that does not parse like a browser gives wrong answers in both directions. We pointed each of our clients at the lab application's /r route, which echoes its parameter into a Location header unchanged, and recorded where each one landed. The base was http://trusted.test/r.
//evil.test/x. curl -L, Python's urllib.request, requests and Node.js's fetch all landed on evil.test./\evil.test/x and \/evil.test/x. fetch landed on evil.test. curl, urllib.request and requests all stayed on trusted.test, treating the backslash as part of a path (requests percent-encoded it as %5C). A scanner that confirms with any of the last three reports a false negative here. That is the third hypothetical finding.///evil.test/x and http:///evil.test/x. curl and fetch landed on evil.test. urllib.request and requests stayed on trusted.test, at the path /evil.test/x.http:evil.test/x, with an http base, so the same scheme. fetch, urllib.request and requests stayed on trusted.test. curl refused it: "The redirect target URL could not be parsed: Unsupported number of slashes following scheme".http://trusted.test\@evil.test/x. curl and requests landed on evil.test. fetch went to trusted.test, at the path /@evil.test/x. A scanner using curl or requests reports an open redirect here that a browser following WHATWG would not take, which is a false positive.http://evil.test\@trusted.test/x. The reverse: curl and requests stayed on trusted.test, and fetch landed on evil.test. A false negative for those two clients.http://[email protected]/x. curl and requests landed on evil.test. fetch refused with "cross origin not allowed for request mode "cors"", because the fetch standard rejects a cross-origin redirect to a URL that carries credentials in that mode. urllib.request handed the whole [email protected] string to http.client as a host name, and name resolution failed. In all three userinfo cases, urllib.request failed the same way./, a tab, then /evil.test/x. urllib.request and fetch removed the tab and landed on evil.test. curl refused: "The redirect target URL could not be parsed: Malformed input to a URL function". requests resolved the value to //evil.test/x and then failed with "No connection adapters were found for '//evil.test/x'".javascript:alert(1) and file:///etc/hostname. All four refused. curl said "Unsupported URL scheme" for the first and 'Protocol "file" not supported or disabled in libcurl' for the second. Its manual page states the default: "By default curl only allows HTTP, HTTPS, FTP and FTPS on redirects (added in 7.65.2)." urllib.request's redirect handler carries the comment "For security reasons we don't allow redirection to anything other than http, https or ftp." and raised "Redirection to url 'javascript:alert(1)' is not allowed". requests raised InvalidSchema and fetch said "URL scheme must be a HTTP(S) scheme".Two practical conclusions. First, a finding confirmed with curl or a Python client and a clean result from the same clients are both only as good as their agreement with WHATWG, and on backslashes, extra slashes and userinfo they disagreed. Confirm with a WHATWG parser, which Node.js's URL class is, or with a real browser. Second, do not decide anything from where a client landed without also recording the raw Location value. The value is what a browser will act on. The landing is one client's interpretation of it.
Most open redirect fixes are allowlists, and many allowlists in code review are one line. We ran seven common checks over a set of inputs, and for each input recorded where Node.js's WHATWG parser sends it, resolved against https://trusted.example/login. The checks were:
value.startswith('/'): "only local paths"./ and not with //.value.startswith('https://trusted.example').urlsplit(value).hostname.endswith('trusted.example'): "our domain and its subdomains".'trusted.example' in value.re.match(r'https://trusted.example', value): anchored at the start only, and the dot not escaped.urlsplit(value).hostname == 'trusted.example': an exact comparison, using Python's parser.What got through, and where the WHATWG parser said it would go:
//evil.example/ passed A, and goes to evil.example./\evil.example/ and /-tab-/evil.example/ passed both A and B, and go to evil.example. B is the check most people write after learning about //.///evil.example/ passed A, and goes to evil.example.https://trusted.example.evil.example/ passed C, E and F, and goes to a host the attacker owns: trusted.example.evil.example is a subdomain of evil.example.https://eviltrusted.example/ passed D and E. endswith without a leading dot accepts any name that ends in the same letters.https://trustedXexample/ passed F, because an unescaped dot in a regular expression matches any character.https://evil.example/?r=https://trusted.example passed E, the substring check.https://[email protected]/ passed C, E and F, and goes to evil.example via userinfo.https://evil.example\@trusted.example/ passed D, E and G, and goes to evil.example. Even the exact comparison passed it, because Python's parser and the WHATWG parser disagree about which side of the backslash the host is on.javascript://trusted.example/%0aalert(1) passed D, E and G, because its host is trusted.example. In a client-side navigation sink, it is script.https://evil.example%[email protected]/ passed D, E and G, and does go to trusted.example, with a user name attached. Harmless as a destination, but a sign that the check is not looking at the whole URL.Every one of the seven checks let through at least one input that a WHATWG parser resolves to a host other than trusted.example, or to script. Two lessons apply beyond this list. Anchor and escape any regular expression that matches a host, and match the host component, not the whole URL. And remember that an exact comparison is only exact with respect to the parser that produced the host, which here was not the browser's.
A correct allowlist answers "is the destination one of ours?" That is a different question from "is the destination safe?", and chains live in the gap.
/a?next=//evil.example, correctly, because it is a same-origin path. If /a has its own open redirect, the chain goes trusted, then trusted, then evil. Every redirect parameter on every allowed host is part of the allowlist./uploads/<file> on your own origin is same-origin and attacker-controlled at the same time. Whether that matters depends on what the file can do once served./%2fevil.example, which stays on trusted.example as a path. If the handler at that path decodes it and redirects again, //evil.example reappears one hop later.When a finding says "redirects only to allowlisted hosts", the follow-up question is what those hosts will do with the next request.
Open redirect findings are often rated low, and often that is right. They are also often the missing link in something worse. The rating should follow from which of the following apply to this application, not from the CWE number.
Phishing on a trusted domain. A link that starts with your domain and ends on the attacker's. Mail filters, link previews and people who check the host before clicking all see your name. The redirect does not give the attacker any access. It lends them your domain's reputation for one hop. That is the baseline, and on its own it is usually low.
OAuth and token leakage. This is the best-known chain that turns low into high. In the authorization code and implicit flows, the authorization server sends the user back to a redirect_uri with a code or token attached, after checking that redirect_uri against the client's registration. RFC 6749 already warned about open redirectors, and RFC 9700, the current security best practice, calls for exact string matching of redirect URIs, because pattern and prefix matching were a recurring source of attacks. The mechanism, described from the specifications rather than measured here:
https://app.example/, or a wildcard subdomain, rather than one exact URI.https://app.example/out?url=.So whether an open redirect is a token-theft primitive depends on facts the DAST finding does not contain: whether the host is an OAuth redirect target, how the authorization server matches redirect URIs, which flow is used, and whether the redirect forwards query strings. Each one can be checked in an afternoon. A finding on the same host as an OAuth callback should not be closed as low until they have been.
SSRF filter bypass by redirect following. Many server-side fetchers check the URL they are given and then call a client that follows redirects. Our lab's /fetch route rejected internal.test, localhost and anything starting with 127., checked against the host parsed by Python's urlsplit, and then fetched with urllib.request. Asked directly for http://internal.test/, it answered "blocked host internal.test". Asked for http://trusted.test/r?to=http://internal.test/, which passed the check because trusted.test was allowed, it followed the redirect and returned the internal service's response. Asked for http://2130706435/, a decimal form of 127.0.0.3, it also returned the internal response, because the string check never saw "127.". The attacker does not even need an open redirect on your domain for this, as they can point the fetcher at their own host and redirect from there. An open redirect on an allowed host matters when the fetcher only accepts certain hosts. The out-of-band post covers how blind SSRF is detected.
Default redirect behaviour, measured: curl does not follow redirects without -L, and with -L it followed the redirect to internal.test. urllib.request, requests and fetch all followed by default, and all four reached the internal service through the redirect. The corresponding switches are allow_redirects=False in requests, redirect: 'manual' or 'error' in fetch, and a redirect handler that refuses in urllib.request. The general practice for fetchers is to disable automatic redirects, validate each hop yourself, and check the resolved IP address at connection time rather than the host name in the string.
CSP path restrictions. Content-Security-Policy allows paths in source lists, but redirects are matched in a way that lets an open redirect on an allowed origin load resources from allowed origins outside the permitted path. The security headers post covers this, citing the paper that concluded path restrictions cannot be relied on. If your policy depends on paths, an open redirect on an allowed origin weakens it.
When it is genuinely low. When none of the above applies: the host is not an OAuth redirect target, no server-side fetcher allows it, no CSP allows it by path, and the redirect cannot be delivered as a link. That last condition is worth checking. A redirect target read only from a POST body protected by a CSRF token, or from server-side session state that the attacker cannot set, cannot be put in a phishing link at all. Rate the remaining phishing case low, record why, and fix it anyway when the fix is cheap, because the conditions that keep it low tend to change without anyone revisiting the finding.
http://trusted.test\@evil.test/x. If browsers follow WHATWG, a link containing it does not take a victim anywhere.And the false negatives, which matter more because they produce no finding to triage: the DOM-based redirect that never appears in a response, the meta refresh that a header-only check ignores, the backslash and extra-slash inputs that a non-WHATWG client follows back to the application, the authenticated handler that a lost session never reached, and payloads refused by a check that a different encoding of the same destination gets through.
An open redirect test sends a browser, or a client, somewhere. The procedure below is general practice. Point the destination at a host you control, never at a real third party, and do not use it to collect anything from a real user.
curl -s -i without -L prints it unchanged.new URL(location, requestUrl) and read its origin. Compare that origin with the marker's origin, not the string with the marker's name.%2f?//host, /\host, ///host, / plus a tab plus /host, https:host and http:host, trusted@host, host\@trusted and the reverse, and trusted.host as a subdomain of a host you control. Record which one passed. That tells you which check the code uses.javascript: reaches a JavaScript sink. If it does, the finding is XSS, and the XSS post applies.In order of preference, all general practice:
?next=billing maps to /account/billing. Nothing the user sends ever becomes a Location value. This is the fix that cannot be bypassed by any parser difference./ that is not followed by another /. Python's own parser removes tabs and newlines, so the rejection has to happen on the raw string first.new URL(value, base) is a WHATWG parser, so u.origin === allowedOrigin with empty username and password is a check a browser will agree with. In Python, urlsplit is not a WHATWG parser, so combine it with the raw-string rejection in step 2, which removes the inputs on which the two parsers disagreed in our tests.We tested both versions of the third option, in Python and in Node.js, against 45 inputs: both lists above plus a few controls and variants. The Python version rejected control characters, whitespace and backslashes on the raw string, accepted a path that starts with one slash, and otherwise required scheme https, no user name or password, and hostname exactly trusted.example with no port. The Node.js version required new URL(value, base).origin to equal https://trusted.example with an empty user name and password. For every value either one accepted, we resolved the accepted value with the WHATWG parser. None landed off-origin. The Python version also rejected a few inputs that are actually same-origin, such as https:evil.example, which resolves to a path. Rejecting a harmless input is the right failure for a redirect check.
For OAuth, the fix belongs on the authorization server: register exact redirect URIs and match them exactly, which is what RFC 9700 asks for. For server-side fetchers, disable automatic redirects and validate the resolved address of every hop.
Static analysis models open redirect as taint from a request value to a redirect sink: a framework's redirect helper, a Location header write, or, in client-side code, assignment to location. The SAST false positive post covers the general failure of crediting a sanitiser against a sink it does not protect, and redirects have their own examples.
quote('//evil.example') returns //evil.example unchanged, because / is in its default safe set. With safe='' it becomes %2F%2Fevil.example, which names a URL again as soon as any later layer decodes it. Encoding only the query part leaves the host alone./, \ or @. It is a sanitiser for HTML output, not for a Location header.startswith('/') will mark A and B above as safe.A confirmed DAST finding tells you that a reachable request produced a redirect to an attacker-chosen origin, but not which line built the Location value. A SAST finding tells you which line passes request data to a redirect sink without a check, but not whether a deployed route reaches it or whether a check upstream rejects it. As with path traversal, each one answers the other's open question.
javascript: in client-side sinks. If a JavaScript sink accepts it, re-file the finding as XSS.Back to the three hypothetical findings.
In the scenario, the /out?url= finding was real, and the low rating did not survive the chain check. /out lived on the same host as the application's OAuth callback, and the identity provider had been configured with a prefix match on that host. An authorization request with redirect_uri set to /out, pointed at a test host the team controlled, delivered an authorization code to that host because /out forwarded the whole query string. The finding went from low to high, a second finding was raised against the identity provider configuration, and both were fixed: /out now maps link identifiers to destinations, and the provider matches one exact callback URI.
In the scenario, the /account/settings?return= finding was the login page. The scan had lost its session, and the Location that contained the marker was /login?return=.... Tested again with a session, the handler resolved return against a fixed list of settings pages and ignored anything else. The finding was closed as not vulnerable, with the authenticated request attached, and a note that the original evidence came from the login redirect.
In the scenario, the /continue?to= clean result was a false negative. The handler checked that the value started with / and not with //, check B above. The scanner's /\marker.example/ payload had produced Location: /\marker.example/, but the scanner's client followed it back onto the application, so the check concluded "same origin". Resolved with a WHATWG parser, the same value named marker.example. The fix rejects backslashes and control characters on the raw string, and the retest used both the original payload and the tab variant.
AppSecD's dynamic and API testing runs Nuclei, Dalfox, SQLMap, Commix, Katana, Arjun, FFuf and Interactsh for out-of-band detection, plus more than 150 native checks and API discovery across more than 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 open redirect check, which payloads, bypass forms or marker hosts it uses, whether it inspects meta refresh, Refresh headers or JavaScript navigation sinks, whether it resolves Location values with a WHATWG parser or follows them with an HTTP client, how it handles authenticated redirect handlers, whether its attack-chain assembly links open redirects to OAuth, SSRF or CSP findings, how it rates the severity of an open redirect, whether its static rules treat any particular check as a sanitiser for redirect sinks, or how accurate its open redirect 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.