In this section, we'll explain reflected cross-site scripting, describe the impact of reflected XSS attacks, and spell out how to find reflected XSS vulnerabilities.
What is reflected cross-site scripting?
Reflected cross-site scripting (or XSS) arises when an application receives data in an HTTP request and includes that data within the immediate response in an unsafe way.
The application echoes the supplied search term in the response to this URL:
<p> You searched for: gift </p>
Assuming the application doesn't perform any other processing of the data, an attacker can construct an attack like this:
https://insecure-website.com/search?term=<script> /*+Bad+stuff+here...+*/ </script>
This URL results in the following response:
<p>You searched for: <script>/* Bad stuff here... */</script></p>
If another user of the application requests the attacker's URL, then the script supplied by the
attacker will execute in the victim user's browser, in the context of their session with the application.
Impact of reflected XSS attacks
If an attacker can control a script that is executed in the victim's browser, then they can typically fully compromise that user.
Amongst other things, the attacker can:
- Perform any action within the application that the user can perform.
- View any information that the user is able to view.
- Modify any information that the user is able to modify.
- Initiate interactions with other application users, including malicious attacks, that will appear to originate from the initial victim user.
There are various means by which an attacker might induce a victim user to make a request that they control, to deliver a reflected XSS attack.
These include placing links on a website controlled by the attacker, or on another website that allows content to be generated, or by sending a
link in an email, tweet or other message. The attack could be targeted directly against a known user, or could an indiscriminate attack against
any users of the application:
The need for an external delivery mechanism for the attack means that the impact of reflected XSS is generally less severe than stored XSS,
where a self-contained attack can be delivered within the vulnerable application itself.
Reflected XSS in different contexts
There are many different varieties of reflected cross-site scripting. The location of the reflected data within the application's
response determines what type of payload is required to exploit it and might also affect the impact of the vulnerability.
In addition, if the application performs any validation or other processing on the submitted data before it is reflected,
this will generally affect what kind of XSS payload is needed.
How to find and test for reflected XSS vulnerabilities
The vast majority of reflected cross-site scripting vulnerabilities can be found quickly and reliably using Burp Suite's
web vulnerability scanner.
Testing for reflected XSS vulnerabilities manually involves the following steps:
Test every entry point.
Test separately every entry point for data within the application's HTTP requests. This includes parameters or other data within the URL query string and message body,
and the URL file path. It also includes HTTP headers, although XSS-like behavior that can only be triggered via certain HTTP headers may not be exploitable in practice.
Submit random alphanumeric values. For each entry point, submit a unique random value and determine whether the value is reflected in the response.
The value should be designed to survive most input validation, so needs to be fairly short and contain only alphanumeric characters. But it needs
to be long enough to make accidental matches within the response highly unlikely. A random alphanumeric value of around 8 characters is normally ideal.
You can use Burp Intruder's number payloads
with randomly generated hex values to generate
suitable random values. And you can use Burp Intruder's
grep payloads option to automatically flag responses that contain the submitted value.
Determine the reflection context. For each location within the response where the random value is reflected, determine its context.
Test a candidate payload. Based on the context of the reflection, test an initial candidate XSS payload that will trigger
to Burp Repeater, modify the request to insert the candidate payload, issue the request, and then review the response to see if
the payload worked. An efficient way to work is to leave the original random value in the request and place the candidate XSS
payload before or after it. Then set the random value as the search term in Burp Repeater's response view. Burp will highlight each location
where the search term appears, letting you quickly locate the reflection.
Test alternative payloads. If the candidate XSS payload was modified by the application, or blocked altogether, then you will need
to test alternative payloads and techniques that might deliver a working XSS attack based on the context of the reflection and the
type of input validation that is being performed. For more details, see cross-site scripting contexts
Test the attack in a browser. Finally, if you succeed in finding a payload that appears to work within Burp Repeater,
transfer the attack to a real browser (by pasting the URL into the address bar, or by modifying the request in
alert(document.domain) which will trigger a visible popup within the browser if the attack succeeds.
Common questions about reflected cross-site scripting
What is the difference between reflected XSS and stored XSS? Reflected XSS arises when an application takes some input from an HTTP
request and embeds that input into the immediate response in an unsafe way. With stored XSS, the application instead stores the input
and embeds it into a later response in an unsafe way.
What is the difference between reflected XSS and self-XSS? Self-XSS involves similar application behavior to regular reflected XSS,
however it cannot be triggered in normal ways via a crafted URL or a cross-domain request. Instead, the vulnerability is only triggered
if the victim themselves submits the XSS payload from their browser. Delivering a self-XSS attack normally involves socially engineering
the victim to paste some attacker-supplied input into their browser. As such, it is normally considered to be a lame, low-impact issue.