The scanner says the parameter redirects. Where does it actually go? Open redirect as a DAST finding: Location, meta refresh and DOM sinks, where URL parsers disagree, naive allowlists, the chains that raise severity, and how the finding gets confirmed

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.

What CWE-601 covers, and the claim a finding must support

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.

Three places a redirect lives, and which of them a scanner sees

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.

What counts as confirmation

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.

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.

Where URL parsers disagree

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.

Why the scanner's HTTP client changes the answer

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.

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.

Naive allowlists, measured

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:

What got through, and where the WHATWG parser said it would go:

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.

Allowlisted is not the same as safe

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.

When a finding says "redirects only to allowlisted hosts", the follow-up question is what those hosts will do with the next request.

Impact, framed honestly

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:

  1. The client registers a pattern or a prefix, such as https://app.example/, or a wildcard subdomain, rather than one exact URI.
  2. Somewhere under that prefix there is an open redirect, such as https://app.example/out?url=.
  3. The attacker starts an authorization request with redirect_uri set to the open redirect, pointed at their host. The authorization server's check passes, because the prefix matches.
  4. The user logs in or has a session already, and the authorization server redirects to the open redirect with the code in the query or the token in the fragment.
  5. The open redirect forwards the browser to the attacker's host. A code in the query is lost if the redirect drops the query string. It survives if the redirect forwards the whole query, and it can also leak in the Referer header of a later request. A token in the fragment survives even a redirect that drops the query: RFC 9110 says that when a Location value has no fragment, the user agent keeps the fragment of the original request. That is a browser behaviour we could not measure here. Node.js's fetch did land on the attacker host in our test, but the fetch standard excludes the fragment from a response's URL, so we could not see whether it carried over.

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.

False positives, and where they come from

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.

Confirming a finding by hand

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.

  1. Record the raw Location value, not just where a client landed. curl -s -i without -L prints it unchanged.
  2. Resolve it with a WHATWG parser. In Node.js, new URL(location, requestUrl) and read its origin. Compare that origin with the marker's origin, not the string with the marker's name.
  3. If the host is the application's, look for a second hop: does the destination path itself take a redirect parameter, or decode a %2f?
  4. If the value was refused, try the bypass forms in order: //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.
  5. Check the other redirect layers. Search the response for a meta refresh or a Refresh header, and load the page in a browser to catch JavaScript sinks. For a DOM-based redirect, find the sink in the page's script.
  6. Check whether javascript: reaches a JavaScript sink. If it does, the finding is XSS, and the XSS post applies.
  7. Test authenticated if the unauthenticated response was a login redirect.
  8. Work out whether the redirect can be delivered as a link: GET or POST, CSRF token, session state.
  9. Check the chains. Is this host or path an OAuth redirect target, and how does the authorization server match redirect URIs? Does any server-side fetcher allow this host and follow redirects? Does a CSP allow this origin with a path?
  10. Keep the evidence: the request, the raw Location value, its resolution, and the client and version used, so that the fix can be retested the same way.

The fix

In order of preference, all general practice:

  1. Do not take a URL. Take an identifier, and map it on the server to a destination: ?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.
  2. Relative paths only, checked strictly. Reject any control character, whitespace or backslash before parsing. Then require a single leading / 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.
  3. Absolute URLs to a fixed set of origins, checked with the parser that will act on them. Parse the value, compare scheme, host and port exactly with the allowed list, reject any URL that has a user name or password, and then send the re-serialised URL you checked rather than the original string. In Node.js, 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.
  4. An interstitial for anything else. A page that says where the link goes and asks the user to click. It turns a silent redirect into a decision, and it is the usual answer for applications that must link to arbitrary external URLs.

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.

The static side: a sanitiser for the wrong sink

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.

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.

A triage checklist for a DAST open redirect finding

  1. Identify the layer. Location header, Refresh header, meta refresh or JavaScript sink. The evidence and the test are different for each.
  2. Resolve the raw value. Use a WHATWG parser against the request URL, and compare origins. Do not search the header for the marker as a string.
  3. Rule out same-origin reflection. A marker in the path or query of a same-origin Location is not an open redirect, unless the destination redirects again.
  4. Rule out the login page. A marker inside a return parameter on a redirect to /login means the handler was not tested. Test it authenticated.
  5. Check how the scanner confirmed it. If it followed the redirect with curl or a Python client, re-check backslash, extra-slash and userinfo cases with a WHATWG parser. Those clients disagreed with WHATWG in both directions in our tests.
  6. Record the bypass that worked, if one was needed. It names the broken check.
  7. Check for javascript: in client-side sinks. If a JavaScript sink accepts it, re-file the finding as XSS.
  8. Check deliverability. GET link, POST with a CSRF token, or session state the attacker cannot set.
  9. Check OAuth. Is the host or path an OAuth redirect target, how are redirect URIs matched, which flow is used, and does the redirect forward the query?
  10. Check server-side fetchers. Does any component that fetches URLs allow this host and follow redirects?
  11. Check CSP. Does a policy allow this origin with a path restriction?
  12. Rate it from 9 to 11, not from the CWE number. Low is right when none apply and the redirect is deliverable only as phishing.
  13. Fix by preference. Map identifiers, then strict relative paths, then exact origins compared with the browser's parser and re-serialised, then an interstitial.
  14. Retest with the evidence that raised the finding, plus the bypass forms, using a WHATWG parser, and confirm the scanner reached the handler rather than a login redirect. The scan-passed post covers how that goes wrong.

The hypothetical findings, resolved

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.

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 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.

More about AppSecD · All posts