Cross-site scripting

From Wikipedia, the free encyclopedia
Jump to: navigation, search



Security on the web depends on a variety of mechanisms, including an underlying concept of trust known as the same-origin policy. This essentially states that if content from one site (such as is granted permission to access resources on a system, then any content from that site will share these permissions, while content from another site ( will have to be granted permissions separately.[2]

Cross-site scripting attacks use known vulnerabilities in web-based applications, their servers, or the plug-in systems on which they rely. Exploiting one of these, attackers fold malicious content into the content being delivered from the compromised site. When the resulting combined content arrives at the client-side web browser, it has all been delivered from the trusted source, and thus operates under the permissions granted to that system. By finding ways of injecting malicious scripts into web pages, an attacker can gain elevated access-privileges to sensitive page content, to session cookies, and to a variety of other information maintained by the browser on behalf of the user. Cross-site scripting attacks are a case of code injection.[citation needed]

Microsoft security-engineers introduced the term "cross-site scripting" in January 2000.[3] The expression "cross-site scripting" originally referred to the act of loading the attacked, third-party web application from an unrelated attack-site, in a manner that executes a fragment of JavaScript prepared by the attacker in the security context of the targeted domain (taking advantage of a reflected or non-persistent XSS vulnerability). The definition gradually expanded to encompass other modes of code injection, including persistent and non-JavaScript vectors (including ActiveX, Java, VBScript, Flash, or even HTML scripts), causing some confusion to newcomers to the field of information security.[4]

XSS vulnerabilities have been reported and exploited since the 1990s. Prominent sites affected in the past include the social-networking sites Twitter,[5] Facebook,[6] MySpace, YouTube and Orkut.[7][8] Cross-site scripting flaws have once surpassed buffer overflows to become the most common publicly reported security vulnerability,[9] with some researchers in 2007 estimating as many as 68% of websites as likely open to XSS attacks.[10]


There is no single, standardized classification of cross-site scripting flaws, but most experts distinguish between at least two primary flavors of XSS flaws: non-persistent and persistent. Some sources further divide these two groups into traditional (caused by server-side code flaws) and DOM-based (in client-side code).

Reflected (non-persistent)[edit]

Example of a non-persistent XSS flaw


The non-persistent (or reflected) cross-site scripting vulnerability is by far the most common type of web vulnerability.[12] These holes show up when the data provided by a web client, most commonly in HTTP query parameters (e.g. HTML form submission), is used immediately by server-side scripts to parse and display a page of results for and to that user, without properly sanitizing the request.[13]




Example of a persistent XSS flaw








Server-side versus DOM-based vulnerabilities[edit]

Example of a DOM-based XSS flaw

Before the bug was resolved, Bugzilla error pages were open to DOM-based XSS attacks in which arbitrary HTML and scripts could be injected using forced error messages.[17]


As the JavaScript code was also processing user input and rendering it in the web page content, a new sub-class of reflected XSS attacks started to appear that was called DOM-based cross-site scripting. In a DOM-based XSS attack, the malicious data does not touch the web server. Rather, it is being reflected by the JavaScript code, fully on the client side.[18]

An example of a DOM-based XSS vulnerability is the bug found in 2011 in a number of JQuery plugins.[19] Prevention strategies for DOM-based XSS attacks include very similar measures to traditional XSS prevention strategies but implemented in JavaScript code and contained in web pages (i.e. input validation and escaping).[20] Some JavaScript frameworks have built-in countermeasures against this and other types of attack — for example Angular.js.[21]


Self-XSS is a form of XSS vulnerability which relies on Social Engineering in order to trick the victim into executing malicious JavaScript code into their browser. Although it is technically not a true XSS vulnerability due to the fact it relies on socially engineering a user into executing code rather than a flaw in the affected website allowing an attacker to do so, it still poses the same risks as a regular XSS vulnerability if properly executed.[22]

Exploit examples[edit]

Attackers intending to exploit cross-site scripting vulnerabilities must approach each class of vulnerability differently. For each class, a specific attack vector is described here. The names below are technical terms, taken from the Alice-and-Bob cast of characters commonly used in computer security.



  1. Alice often visits a particular website, which is hosted by Bob. Bob's website allows Alice to log in with a username/password pair and stores sensitive data, such as billing information. When a user logs in, the browser keeps an Authorization Cookie, which looks like some garbage characters, so both computers (client and server) remember that she's logged in.
    1. When she visits the Search page, she inputs a search term in the search box and clicks the submit button. If no results were found, the page will display the term she searched for followed by the words "not found," and the url will be search term.
      1. An alert box appears (that says "xss").
      2. The page displays "<script type='text/javascript'>alert('xss');</script> not found," along with an error message with the text 'xss'.
  3. Mallory crafts a URL to exploit the vulnerability:
    1. She makes the URL<script%20src=""></script>. She could choose to convert the ASCII characters into hexadecimal format, such as, so that human readers cannot immediately decipher the malicious URL.[23]
    2. She sends an e-mail to some unsuspecting members of Bob's site, saying "Check out some cute puppies!"
  4. Alice gets the e-mail. She loves puppies and clicks on the link. It goes to Bob's website to search, doesn't find anything, and displays "puppies not found" but right in the middle, the script tag runs (it is invisible on the screen) and loads and runs Mallory's program authstealer.js (triggering the XSS attack). Alice forgets about it.
  5. The authstealer.js program runs in Alice's browser, as if it originated from Bob's website. It grabs a copy of Alice's Authorization Cookie and sends it to Mallory's server, where Mallory retrieves it.
  6. Mallory now puts Alice's Authorization Cookie into her browser as if it were her own. She then goes to Bob's site and is now logged in as Alice.
  7. Now that she's in, Mallory goes to the Billing section of the website and looks up Alice's credit card number and grabs a copy. Then she goes and changes her password so Alice can't even log in anymore.
  8. She decides to take it a step further and sends a similarly crafted link to Bob himself, thus gaining administrator privileges to Bob's website.

Several things could have been done to mitigate this attack:

  1. The search input could have been sanitized which would include proper encoding checking.
  2. The web server could be set to redirect invalid requests.
  3. The web server could detect a simultaneous login and invalidate the sessions.
  4. The web server could detect a simultaneous login from two different IP addresses and invalidate the sessions.
  5. The website could display only the last few digits of a previously used credit card.
  6. The website could require users to enter their passwords again before changing their registration information.
  7. The website could enact various aspects of the Content Security Policy.
  8. Users could be educated to not click "benign-looking," but malicious, links.

Persistent attack[edit]

  1. Mallory gets an account on Bob's website.
  2. Mallory observes that Bob's website contains a stored XSS vulnerability. If you go to the News section, and post a comment, it will display whatever he types in for the comment. But, if the comment text contains HTML tags in it, the tags will be displayed as it is, and any script tags get run.
  3. Mallory reads an article in the News section and writes in a comment at the bottom in the Comments section. In the comment, she inserts this text: I love the puppies in this story! They're so cute!<script src="">
  4. When Alice (or anyone else) loads the page with the comment, Mallory's script tag runs and steals Alice's authorization cookie, sending it to Mallory's secret server for collection.[23]
  5. Mallory can now hijack Alice's session and impersonate Alice.[24][23]

Bob's website software should have stripped out the script tag or done something to make sure it didn't work, but the security bug is in the fact that he didn't.

Preventive measures[edit]

Contextual output encoding/escaping of string input[edit]

Contextual output encoding/escaping could be used as the primary defense mechanism to stop XSS attacks. There are several escaping schemes that can be used depending on where the untrusted string needs to be placed within an HTML document including HTML entity encoding, JavaScript escaping, CSS escaping, and URL (or percent) encoding.[25] Most web applications that do not need to accept rich data can use escaping to largely eliminate the risk of XSS attacks in a fairly straightforward manner.

Although widely recommended, performing HTML entity encoding only on the five XML significant characters is not always sufficient to prevent many forms of XSS attacks. As encoding is often difficult, security encoding libraries are usually easier to use.[25]

Safely validating untrusted HTML input[edit]

Many operators of particular web applications (e.g. forums and webmail) allow users to utilize a limited subset of HTML markup. When accepting HTML input from users (say, <b>very</b> large), output encoding (such as &lt;b&gt;very&lt;/b&gt; large) will not suffice since the user input needs to be rendered as HTML by the browser (so it shows as "very large", instead of "<b>very</b> large"). Stopping an XSS attack when accepting HTML input from users is much more complex in this situation. Untrusted HTML input must be run through an HTML sanitization engine to ensure that it does not contain XSS code.

It should also be noted that many validations rely on parsing out (blacklisting) specific "at risk" html tags such as the following

<script> <link> <iframe>

There are several issues with this approach, for example sometimes seemingly harmless tags can be left out which when utilized correctly can still result in an XSS

(see the below example)

<img src="javascript:alert(1)">

Another popular method is to strip user input of " and ' however this can also be bypassed as the payload can be concealed with Obfuscation (See this [1] link for an extreme example of this)

Cookie security[edit]

Besides content filtering, other imperfect methods for cross-site scripting mitigation are also commonly used. One example is the use of additional security controls when handling cookie-based user authentication. Many web applications rely on session cookies for authentication between individual HTTP requests, and because client-side scripts generally have access to these cookies, simple XSS exploits can steal these cookies.[26] To mitigate this particular threat (though not the XSS problem in general), many web applications tie session cookies to the IP address of the user who originally logged in, then only permit that IP to use that cookie.[27] This is effective in most situations (if an attacker is only after the cookie), but obviously breaks down in situations where an attacker is behind the same NATed IP address or web proxy as the victim, or the victim is changing his or her mobile IP.[27]

Another mitigation present in Internet Explorer (since version 6), Firefox (since version, Safari (since version 4), Opera (since version 9.5) and Google Chrome, is an HttpOnly flag which allows a web server to set a cookie that is unavailable to client-side scripts. While beneficial, the feature can neither fully prevent cookie theft nor prevent attacks within the browser.[28]

Disabling scripts[edit]

While Web 2.0 and Ajax designers favor the use of JavaScript,[29] some web applications are written to allow operation without the need for any client-side scripts.[30] This allows users, if they choose, to disable scripting in their browsers before using the application. In this way, even potentially malicious client-side scripts could be inserted unescaped on a page, and users would not be susceptible to XSS attacks.

Some browsers or browser plugins can be configured to disable client-side scripts on a per-domain basis. This approach is of limited value if scripting is allowed by default, since it blocks bad sites only after the user knows that they are bad, which is too late. Functionality that blocks all scripting and external inclusions by default and then allows the user to enable it on a per-domain basis is more effective. This has been possible for a long time in Internet Explorer (since version 4) by setting up its so called "Security Zones",[31] and in Opera (since version 9) using its "Site Specific Preferences".[32] A solution for Firefox and other Gecko-based browsers is the open source NoScript add-on which, in addition to the ability to enable scripts on a per-domain basis, provides some XSS protection even when scripts are enabled.[33]


Emerging defensive technologies[edit]

There are three classes of XSS defense that are emerging. These include Content Security Policy,[37] Javascript sandbox tools, and auto-escaping templates. These mechanisms are still evolving but promise a future of heavily reduced XSS attack occurrence.

Scanning service[edit]

Some companies offer a periodic scan service, essentially simulating an attack from their server to a client's in order to check if the attack is successful. If the attack succeeds, the client receives detailed information on how it was performed and thus has a chance to fix the issues before the same attack is attempted by someone else. A trust seal can be displayed on the site that passes a recent scan. The scanner may not find all possible vulnerabilities,[38] and therefore sites with trust seals may still be vulnerable to new types of attack, but the scan may detect some problems. After the client fixes them, the site is more secure than it was before using the service. For sites that require complete mitigation of XSS vulnerabilities, assessment techniques like manual code review are necessary. Additionally, if Javascript is executing on the page, the seal could be overwritten with a static copy of the seal (so, in theory, such a service alone is likely not sufficient to eliminate XSS risk completely).

Related vulnerabilities[edit]

In a Universal Cross-Site Scripting (UXSS, or Universal XSS) attack, vulnerabilities in the browser itself are exploited (rather than vulnerabilities in other websites, as is the case with XSS attacks); such attacks are commonly used by Anonymous, along with DDoS, to compromise control of a network.[39]

Several classes of vulnerabilities or attack techniques are related to XSS: cross-zone scripting exploits "zone" concepts in certain browsers and usually executes code with a greater privilege.[40] HTTP header injection can be used to create cross-site scripting conditions due to escaping problems on HTTP protocol level (in addition to enabling attacks such as HTTP response splitting).[41]

Cross-site request forgery (CSRF/XSRF) is almost the opposite of XSS, in that rather than exploiting the user's trust in a site, the attacker (and his malicious page) exploits the site's trust in the client software, submitting requests that the site believes represent conscious and intentional actions of authenticated users.[42] XSS vulnerabilities (even in other applications running on the same domain) allow attackers to bypass CSRF prevention efforts.[43]

Covert Redirect takes advantage of third-party clients susceptible to XSS or Open Redirect attacks.[44] Covert Redirect was discovered by a mathematical Ph.D. student named Wang Jing from Nanyang Technological University, Singapore. "Normal phishing attempts can be easy to spot, because the malicious page's URL will usually be off by a couple of letters from that of the real site. The difference with Covert Redirect is that an attacker could use the real website instead by corrupting the site with a malicious login pop-up dialogue box."[45]


See also[edit]


  1. ^ During the second half of 2007, 11,253 site-specific cross-site vulnerabilities were documented by XSSed, compared to 2,134 "traditional" vulnerabilities documented by Symantec, in "Symantec Internet Security Threat Report: Trends for July–December 2007 (Executive Summary)" (PDF). XIII. Symantec Corp. April 2008: 1–3. Retrieved May 11, 2008. 
  2. ^ "Same Origin Policy - Web Security.". Retrieved November 4, 2014. 
  3. ^ "dross" on MSDN (15 Dec 2009). "Happy 10th birthday Cross-Site Scripting!". Retrieved 2016-03-19. On the 16th of January, 2000, the following names were suggested and bounced around among a small group of Microsoft security engineers: [...] The next day there was consensus – Cross Site Scripting. 
  8. ^ Dignan, Larry (April 21, 2008). "Obama site hacked; Redirected to Hillary Clinton". ZDNet. Retrieved May 28, 2008. 
  10. ^ Berinato, Scott (January 1, 2007). "Software Vulnerability Disclosure: The Chilling Effect". CSO. CXO Media. p. 7. Archived from the original on April 18, 2008. Retrieved June 7, 2008. 
  14. ^ Grossman, Jeremiah; Hansen, Robert; Fogie, Seth; Petkov, Petko D.; Rager, Anton (2007). XSS Attacks: Cross Site Scripting Exploits and Defense (Abstract). Elsevier Science & Technology via Google Book Search. pp. 70, 156. ISBN 1-59749-154-3. Retrieved May 28, 2008. 
  18. ^ "DOM based XSS". OWASP. 
  19. ^ "JQuery bug #9521". 2011. 
  21. ^ "Strict Contextual Escaping". Angular.js. 
  22. ^ "Self-XSS Facebook scam attempts to trick users into hacking themselves". 2014-07-29. Retrieved 2016-09-20. 
  23. ^ a b c
  24. ^ Brodkin, Jon (October 4, 2007). "The top 10 reasons Web sites get hacked". Network World. IDG. Retrieved June 8, 2008. 
  31. ^ "How to use security zones in Internet Explorer". Microsoft. December 18, 2007. Retrieved June 4, 2008. 
  32. ^ Lie, Håkon Wium (February 7, 2006). "Opera 9 Technology Preview 2". Opera Software. Retrieved June 4, 2008. 
  33. ^ "NoScript". Mozilla. May 30, 2008. Retrieved June 4, 2008.  and Mogull, Rich (March 18, 2008). "Should Mac Users Run Antivirus Software?". TidBITS. TidBITS Publishing. Retrieved June 4, 2008. 
  36. ^ "NoScript Features". Retrieved March 7, 2009. 
  37. ^ "Content Security Policy 1.0". W3C Candidate Recommendation. November 15, 2012. Retrieved February 22, 2013. 
  38. ^ Sceptic blog
  39. ^ Di Paola, Stefano (January 3, 2007). "Adobe Acrobat Reader Plugin - Multiple Vulnerabilities". Retrieved March 13, 2012. 
  43. ^ "Article about CSRF and same-origin XSS"
  44. ^ "OAuth 2.0 and OpenID Redirect Vulnerability". Hacker News. May 2, 2014. Retrieved December 21, 2014. 
  45. ^ Scharr, Jill (May 2, 2014). "Facebook, Google Users Threatened by New Security Flaw". Tom's Guide. Retrieved December 21, 2014. 

Further reading[edit]

External links[edit]