This site is the archived OWASP Foundation Wiki and is no longer accepting Account Requests.
To view the new OWASP Foundation website, please visit https://owasp.org
Cross-Site Request Forgery (CSRF) Prevention Cheat Sheet
|
Last revision (mm/dd/yy): 01/23/2019
IntroductionCross-Site Request Forgery (CSRF) is a type of attack that occurs when a malicious web site, email, blog, instant message, or program causes a user’s web browser to perform an unwanted action on a trusted site when the user is authenticated. A CSRF attack works because browser requests automatically include any credentials associated with the site, such as the user's session cookie, IP address, etc. Therefore, if the user is authenticated to the site, the site cannot distinguish between the forged or legitimate request sent by the victim. We would need a token/identifier that is not accessible to attacker and would not be sent along (like cookies) with forged requests that attacker initiates. For more information on CSRF, see OWASP Cross-Site Request Forgery (CSRF) page. The impact of a successful CSRF attack is limited to the capabilities exposed by the vulnerable application. For example, this attack could result in a transfer of funds, changing a password, or making a purchase with the user’s credentials. In effect, CSRF attacks are used by an attacker to make a target system perform a function via the target's browser, without the user’s knowledge, at least until the unauthorized transaction has been committed. Impacts of successful CSRF exploits vary greatly based on the privileges of each victim. When targeting a normal user, a successful CSRF attack can compromise end-user data and their associated functions. If the targeted end user is an administrator account, a CSRF attack can compromise the entire web application. Using social engineering, an attacker can embed malicious HTML or JavaScript code into an email or website to request a specific 'task URL'. The task then executes with or without the user's knowledge, either directly or by using a Cross-Site Scripting flaw. For example, see Samy MySpace Worm. What's new?If you have seen OWASP old CSRF prevention cheat sheets, you can observe that a lot has changed in this newer version. One of the major changes is that the “Verifying same origin with standard headers” CSRF defense has been moved to the Defense-in-Depth section, whereas token based mitigation moved to the Primary Defenses section (technical reasons for this switch were added under respective sections). Multiple new sections (HMAC based token protection, auto CSRF mitigation techniques, login CSRF, not so popular CSRF mitigations and CSRF mitigation myths) were added besides adding new content, removing obsolete content to the existing sections. Security issues/caveats associated with each mitigation were also included. Warning: No Cross-Site Scripting (XSS) VulnerabilitiesCross-Site Scripting is not necessary for CSRF to work. However, any cross-site scripting vulnerability can be used to defeat all CSRF mitigation techniques available in the market today (except mitigation techniques that involve user interaction and described later in this cheat sheet). This is because an XSS payload can simply read any page on the site using an XMLHttpRequest (direct DOM access can be done, if on same page) and obtain the generated token from the response, and include that token with a forged request. This technique is exactly how the MySpace (Samy) worm defeated MySpace's anti-CSRF defenses in 2005, which enabled the worm to propagate. It is imperative that no XSS vulnerabilities are present to ensure that CSRF defenses can't be circumvented. Please see the OWASP XSS Prevention Cheat Sheet for detailed guidance on how to prevent XSS flaws. Resources that need to be protected from CSRF vulnerabilityThe following list assumes that you are not violating RFC2616, section 9.1.1, by using GET requests for state changing operations. Note: If for any reason you violate, you would also need to protect those resources, which is mostly achieved with default
CSRF Defense Recommendations SummaryWe recommend token based CSRF defense (either stateful/stateless) as a primary defense to mitigate CSRF in your applications. Only for highly sensitive operations, we also recommend a user interaction based protection (either re-authentication/one-time token, detailed in section 7.5) along with token based mitigation. As a defense-in-depth measure, consider implementing one mitigation from the Defense-in-Depth Techniques section (you can choose the mitigation that fits your ecosystem considering the issues mentioned under them). These defense-in-depth mitigation techniques are not recommended to be used by themselves (without token based mitigation) for mitigating CSRF in your applications. Primary Defense TechniquesToken Based MitigationThis defense is one the most popular and recommended methods to mitigate CSRF. It can be achieved either with state (synchronizer token pattern) or stateless (encrypted/hash based token pattern). See section 6.3 on how to mitigate login CSRF in your applications. For all the mitigation's, it is implicit that general security principles should be adhered
Note: You can select any algorithm per your organizational needs. We recommend AES256-GCM for encryption and SHA256/512 for HMAC.
Synchronizer Token PatternAny state changing operation requires a secure random token (e.g., CSRF token) to prevent CSRF attacks. A CSRF token should be unique per user session, large random value, and also generated by a cryptographically secure random number generator. The CSRF token is added as a hidden field for forms headers/parameters for AJAX calls, and within the URL if the state changing operation occurs via a GET. See "Disclosure of Token in URL" section below. The server rejects the requested action if the CSRF token fails validation. In order to facilitate a "transparent but visible" CSRF solution, developers are encouraged to adopt a pattern similar to Synchronizer Token Pattern (The original intention of this synchronizer token pattern was to detect duplicate submissions in forms). The synchronizer token pattern requires the generation of random "challenge" tokens that are associated with the user's current session. These challenge tokens are then inserted within the HTML forms and calls associated with sensitive server-side operations. It is the responsibility of the server application to verify the existence and correctness of this token. By including a challenge token with each request, the developer has a strong control to verify that the user actually intended to submit the desired requests. Inclusion of a required security token in HTTP requests associated with sensitive business functions helps mitigate CSRF attacks as successful exploitation assumes the attacker knows the randomly generated token for the target victim's session. Note: These tokens aren’t like cookies that are automatically sent with forged requests made from your browser from the attacker website. This is analogous to the attacker being able to guess the target victim's session identifier. The following describes a general approach to incorporate challenge tokens within the request. When a Web application formulates a request, the application should include a hidden input parameter with a common name such as "CSRFToken" (for forms)/ as header/parameter value for Ajax calls. The value of this token must be randomly generated such that it cannot be guessed by an attacker. Consider leveraging the java.security.SecureRandom class for Java applications to generate a sufficiently long random token. Alternative generation algorithms include the use of 256-bit BASE64 encoded hashes. Developers that choose this generation algorithm must make sure that there is randomness and uniqueness utilized in the data that is hashed to generate the random token. <form action="/transfer.do" method="post">
<input type="hidden" name="CSRFToken"
value="OWY4NmQwODE4ODRjN2Q2NTlhMmZlYWEwYzU1YWQwMTVhM2JmNGYxYjJiMGI4MjJjZDE1ZDZMGYwMGEwOA==">
...
</form>In general, developers need only generate this token once for the current session. After initial generation of this token, the value is stored in the session and is used for each subsequent request until the session expires. When a request is issued by the end-user, the server-side component must verify the existence and validity of the token in the request compared to the token found in the user session. If the token was not found within the request, or the value provided does not match the value within the user session, then the request should be aborted, and the event logged as a potential CSRF attack in progress. To further enhance the security of this proposed design, consider randomizing the CSRF token parameter name and/or value for each request. Implementing this approach results in the generation of per-request tokens as opposed to per-session tokens. This is more secure than per-session tokens as the time range for an attacker to exploit the stolen tokens is minimal. However, this may result in usability concerns. For example, the "Back" button browser capability is often hindered as the previous page may contain a token that is no longer valid. Interaction with this previous page will result in a CSRF false positive security event at the server. Few applications that need high security typically implement this approach (such as banks). You have to check what suits your needs. Regardless of the approach taken, developers are encouraged to protect the CSRF token the same way they protect authenticated session identifiers, such as the use of TLS. Existing Synchronizer Implementations Synchronizer token defenses have been built into many frameworks, so we strongly recommend using them first when they are available. External components that add CSRF defenses to existing applications are also recommended. OWASP has the following:
Disclosure of Token in URL Some implementations of synchronizer tokens include the challenge token in GET (URL) requests as well as POST requests. This is often implemented as a result of sensitive server-side operations being invoked as a result of embedded links in the page or other general design patterns. These patterns are often implemented without knowledge of CSRF and an understanding of CSRF prevention design strategies. While this control does help mitigate the risk of CSRF attacks, the unique per-session token is being exposed for GET requests. CSRF tokens in GET requests are potentially leaked at several locations: browser history, log files, network appliances that make a point to log the first line of an HTTP request, and Referer headers if the protected site links to an external site. In the latter case (leaked CSRF token due to the Referer header being parsed by a linked site), it is trivially easy for the linked site to launch a CSRF attack on the protected site, and they will be able to target this attack very effectively, since the Referer header tells them the site as well as the CSRF token. The attack could be run entirely from JavaScript, so that a simple addition of a script tag to the HTML of a site can launch an attack (whether on an originally malicious site or on a hacked site). Additionally, since HTTPS requests from HTTPS contexts will not strip the Referer header (as opposed to HTTPS to HTTP requests) CSRF token leaks via Referer can still happen on HTTPS Applications. The ideal solution is to only include the CSRF token in POST requests and modify server-side actions that have state changing affect to only respond to POST requests. This is in fact what the RFC 2616 requires for GET requests. If sensitive server-side actions are guaranteed to only ever respond to POST requests, then there is no need to include the token in GET requests. In most JavaEE web applications, however, HTTP method scoping is rarely ever utilized when retrieving HTTP parameters from a request. Calls to "HttpServletRequest.getParameter" will return a parameter value regardless if it was a GET or POST. This is not to say HTTP method scoping cannot be enforced. It can be achieved if a developer explicitly overrides doPost() in the HttpServlet class or leverages framework specific capabilities such as the AbstractFormController class in Spring. For these cases, attempting to retrofit this pattern in existing applications requires significant development time and cost, and as a temporary measure it may be better to pass CSRF tokens in the URL. Once the application has been fixed to respond to HTTP GET and POST verbs correctly, CSRF tokens for GET requests should be turned off. Encryption based Token PatternThe Encrypted Token Pattern leverages an encryption, rather than comparison method of Token-validation. It is most suitable for applications that do not want to maintain any state at server side. After successful authentication, the server generates a unique token comprised of the user's ID, a timestamp value and a nonce, using a unique key available only on the server. This token is returned to the client and embedded in a hidden field for forms, in the request-header/parameter for AJAX requests. On receipt of this request, the server reads and decrypts the token value with the same key used to create the token. The inability to correctly decrypt suggests an intrusion attempt. Once decrypted, the UserId and timestamp contained within the token are validated; the UserId is compared against the currently logged in user, and the timestamp is compared against the current time. On successful token-decryption, the server has access to parsed values, ideally in the form of claims. These claims are processed by comparing the UserId claim to any potentially stored UserId (in a Cookie or Session variable, if the site already contains a means of authentication). The Timestamp is validated against the current time, preventing replay attacks. Alternatively, in the case of a CSRF attack, the server will be unable to decrypt the poisoned token, and can block and log the attack. This technique addresses some of the shortfalls in other stateless approaches, such as the need to store data in a Cookie, circumventing the Cookie-subdomain and HttpOnly issues. HMAC Based Token PatternHMAC (hash-based message authentication code) is a cryptographic function that helps to guarantee integrity and authentication of a message. It is another way that CSRF mitigation can be achieved without maintaining any state at the server and is similar to an encryption token-based pattern with two main differences:
(Ex: ‘oneclickpurchase’ (or) buy/asin=SDFH&category=2&quantity=3) Note: Fields mentioned in encryption token pattern (user's ID, a timestamp value and a nonce) are included. The operation field helps in mitigating the fact that the hash function generates the same value irrespective of multiple iterations (unlike strong encryption functions that generate different values when they are encrypted each time). So, it would help in avoiding having repeated token values across your application. Nonce field serves the same purpose as in encrypted token pattern (i.e., to avoid rare collisions due to weak cryptographic functions and acts as a defense-in-depth measure). Generate the token using HMAC including all four fields mentioned previously (user's ID, a timestamp value, nonce, and operation) and then include it in hidden fields for form tags, headers/parameters for ajax calls. Once you receive the HMAC from the client in the requests, re-generate HMAC with the same fields that you used to generate it, and then verify that the HMAC you re-generated matches the HMAC received from the client. If it does, it is a legitimate user request and if it does not, flag it as a CSRF intrusion and alert your incident response teams. Because an attacker has no visibility into the key used for generating the hash fields used in generating it, there is no way for them to re-generate it to use in forged request. Auto CSRF Mitigation TechniquesThough the technique of mitigating tokens is widely used (stateful with synchronizer token and stateless with encrypted/HMAC token), the major problem associated with these techniques is the human tendency to forget things at times. If a developer forgets to add the token to any state changing operation, they are making the application vulnerable to CSRF. To avoid this, you can try to automate the process of adding tokens to CSRF vulnerable resources (mentioned earlier in this document). You can achieve this by doing the following:
We recommend researching if the framework you are using has an option to achieve CSRF protection by default before trying to build your custom auto tokening system. For example, .NET has an in-built protection that adds token to CSRF vulnerable resources. You are responsible for proper configuration (such as key management and token management) before using these in-built CSRF protections that do auto tokening to CSRF vulnerable resources. Login CSRFMost developers tend to ignore CSRF vulnerability on login forms as they assume that CSRF would not be applicable on login forms because user is not authenticated at that stage. That assumption is false. CSRF vulnerability can still occur on login forms where the user is not authenticated, but the impact/risk view for it is quite different from the impact/risk view of a general CSRF vulnerability (when a user is authenticated). With a CSRF vulnerability on login form, an attacker can make a victim login to the attacker's account and learn behavior from the victim's searches. For more information about login CSRF and other risks, see section 3 of the Stanford CSRF paper. Login CSRF can be mitigated by creating pre-sessions (sessions before a user is authenticated) and including tokens in login form. You can use any of the techniques mentioned above to generate tokens. Pre-sessions can be transitioned to real sessions once the user is authenticated. This technique is described in Robust Defenses for Cross-Site Request Forgery section 4.1. If sub-domains under your master domain are treated as not trusted in your threat model, it is difficult to mitigate login CSRF. A strict subdomain and path level referer header (because most login pages are served on HTTPS - no stripping of referer - and are also linked from home pages) validation (detailed in section 7.1) can be used in these cases for mitigating CSRF on login forms to an extent. Defense-In-Depth TechniquesVerifying origin with standard headersThis defense technique is specifically proposed in section 5.0 of Robust Defenses for Cross-Site Request Forgery. This paper proposes the first creation of the Origin header and its use as a CSRF defense mechanism. There are two steps to this mitigation, both of which rely on examining an HTTP request header value. 1. Determining the origin the request is coming from (source origin). Can be done via Origin and/or referer header. 2. Determining the origin the request is going to (target origin). At server side we verify if both of them match. If they do, we accept the request as legitimate (meaning it’s the same origin request) and if they don’t, we discard the request (meaning that the request originated from cross-domain). Reliability on these headers comes from the fact that they cannot be altered programmatically (using JavaScript in an XSS) as they fall under forbidden headers list (i.e., only browsers can set them). Identifying Source Origin (via Origin/Referer header)Checking the Origin Header If the Origin header is present, verify that its value matches the target origin. Unlike the Referer, the Origin header will be present in HTTP requests that originate from an HTTPS URL. Checking the Referer Header If the Origin header is not present, verify the hostname in the Referer header matches the target origin. This method of CSRF mitigation is also commonly used with unauthenticated requests, such as requests made prior to establishing a session state, which is required to keep track of a synchronization token. In both cases, make sure the target origin check is strong. For example, if your site is "site.com" make sure "site.com.attacker.com" does not pass your origin check (i.e., match through the trailing/after the origin to make sure you are matching against the entire origin). If neither of these headers are present, you can either accept or block the request. We recommend blocking. Alternatively, you might want to log all such instances, monitor their use cases/behavior, and then start blocking requests only after you get enough confidence. Identifying the Target OriginYou might think it’s easy to determine the target origin, but it’s frequently not. The first thought is to simply grab the target origin (i.e., its hostname and port #) from the URL in the request. However, the application server is frequently sitting behind one or more proxies and the original URL is different from the URL the app server actually receives. If your application server is directly accessed by its users, then using the origin in the URL is fine and you're all set. If you are behind a proxy, there are a number of options to consider.
This mitigation in earlier versions of the CSRF Cheat Sheet is treated as a primary defense. For reasons mentioned below, it is now moved to the Defense-in-Depth section. As it’s implicit, this mitigation would work properly when origin or referer headers are present in the requests. Though these headers are included majority of the time, there are few use cases where they are not included (most of them are for legitimate reasons to safeguard users privacy/to tune to browsers ecosystem). The following lists some use cases:
Though exceptions can be written for above cases in your source and target origin check logic, there is currently no central repository (even there is one, keeping it up-to-date is a problem) that references all such use cases. Each browser might also handle these use cases differently (browsers are known to handle things differently considering their ecosystem. IE example of not sending origin header within trusted zone is such example). Rejecting requests that do not contain origin and/or referer headers might sound like a good idea but it can impact legitimate users. Keeping this system in monitoring mode and trying to investigate use cases such as stated above, then adding them into exception logic is a process that you may consider to make this defense more stable in your environment. This CSRF defense relies on browser behavior that can change at times. For example, when new privacy contexts are discovered, under which situations you have to keep your validation logic updated, where as in token based mitigation, you have full control on the CSRF mitigation. If browsers alter CSRF tokens, they are literally changing the HTML content on rendering pages (which no browser would ever want to do!). When there is an XSS vulnerability on a page of an application protected with Origin and/or Referer header, the level of effort required to exploit state changing operations (that are typically vulnerable to CSRF) on other pages is very easy (grab the parameters and forge a request, as Origin and Referer header is included by default by browsers) than compared to token based mitigation (where attacker needs to download the target page, parse the DOM for the token, construct a forge request, and send it to server). Note: Although the concept of an origin header stemmed from the Stanford CSRF paper that references robust CSRF defenses, the initial origin header RFC does not reference mitigating CSRF in any way (another draft version does, however). Double Submit CookieIf maintaining the state for CSRF token at server side is problematic, an alternative defense is to use the double submit cookie technique. This technique is easy to implement and is stateless. In this technique, we send a random value in both a cookie and as a request parameter, with the server verifying if the cookie value and request value match. When a user visits (even before authenticating to prevent login CSRF), the site should generate a (cryptographically strong) pseudorandom value and set it as a cookie on the user's machine separate from the session identifier. The site then requires that every transaction request include this pseudorandom value as a hidden form value (or other request parameter/header). If both of them match at server side, the server accepts it as legitimate request and if they don’t, it would reject the request. There’s a belief that this technique would work because a cross origin attacker cannot read any data sent from the server or modify cookie values, per the same-origin policy. This means that while an attacker can force a victim to send any value with a malicious CSRF request, the attacker will be unable to modify or read the value stored in the cookie (with which the server compares the token value). There are a couple of drawbacks associated with the assumptions made here. The problem of "trusting of sub domains and proper configuration of whole site in general to accept HTTPS connections only". The Blackhat talk by Rich Lundeen references these drawbacks. "With double submit, if an attacker can write a cookie they can obviously defeat the protection. And again, writing cookies is significantly easier then reading them. The fact that cookies can be written is difficult for many people to understand. After all, doesn't the same origin policy specify that one domain cannot access cookies from another domain? However, there are two common scenarios where writing cookies across domains is possible: a) While it's true that hellokitty.marketing.example.com cannot read cookies or access the DOM from secure.example.com because of the same origin policy, hellokitty.marketing.example.com can write cookies to the parent domain (example.com), and these cookies are then consumed by secure.example.com (secure.example.com has no good way to distinguish which site set the cookie). Additionally, there are methods of forcing secure.example.com to always accept your cookie first. What this means is that XSS in hellokitty.marketing.example.com is able to overwrite cookies in secure.example.com. b) If an attacker is in the middle, they can usually force a request to the same domain over HTTP. If an application is hosted at https://secure.example.com, even if the cookies are set with the secure flag, a man in the middle can force connections to http://secure.example.com and set (overwrite) any arbitrary cookies (even though the secure flag prevents the attacker from reading those cookies). Even if the HSTS header is set on the server and the browser visiting the site supports HSTS (this would prevent a man in the middle from forcing plain text HTTP requests) unless the HSTS header is set in a way that includes all subdomains, a man in the middle can simply force a request to a separate subdomain and overwrite cookies similar to 1. In other words, as long as http://hellokitty.marketing.example.com doesn't force HTTPS, then an attacker can overwrite cookies on any example.com subdomain." So, unless you are sure that your subdomains are fully secured and only accept HTTPS connections (we believe it’s difficult to guarantee at large enterprises), you should not rely on the Double Submit Cookie technique as a primary mitigation for CSRF. A variant of double submit cookie that can mitigate both the risks mentioned above is including the token in an encrypted cookie - often within the authentication cookie - and then at the server side matching it (after decrypting the authentication cookie) with the token in hidden form field or parameter/header for ajax calls. This works because a sub domain has no way to over-write an properly crafted encrypted cookie without the necessary information such as encryption key. SameSite Cookie AttributeSameSite is a cookie attribute (similar to HttpOnly, Secure etc.) introduced by Google to mitigate CSRF attacks. It is defined in this Internet Draft. This attribute helps in preventing the browser from sending cookies along with cross-site requests. Possible values for this attribute are lax or strict. The strict value will prevent the cookie from being sent by the browser to the target site in all cross-site browsing context, even when following a regular link. For example, for a GitHub-like website this would mean that if a logged-in user follows a link to a private GitHub project posted on a corporate discussion forum or email, GitHub will not receive the session cookie and the user will not be able to access the project. A bank website however most likely doesn't want to allow any transactional pages to be linked from external sites, so the strict flag would be most appropriate. The default lax value provides a reasonable balance between security and usability for websites that want to maintain user's logged-in session after the user arrives from an external link. In the above GitHub scenario, the session cookie would be allowed when following a regular link from an external website while blocking it in CSRF-prone request methods such as POST. Only cross-site requests that are allowed in lax mode are the ones that have top-level navigations and are also “safe” HTTP methods (more details here). Example of cookies using this attribute: Set-Cookie: JSESSIONID=xxxxx; SameSite=Strict Set-Cookie: JSESSIONID=xxxxx; SameSite=Lax Support for this attribute in different browsers is increasing but there are still browsers that need to adopt this. As of August 2018, SameSite attribute is on browsers used by 68.92% of Internet users (detailed statistics are here). Though this technique seems to be efficient in mitigating CSRF attacks, it is still in early stages (in draft) and does not have full browser support as mentioned above. Google’s draft also mentions a couple cases where forged requests can be simulated by attackers as same-site requests (and thus allowing to send SameSite cookies). Considering the factors above, it is not recommended to be used as a primary defense. Google agrees with this stance and strongly encourages developers to deploy server-side defenses such as tokens to mitigate CSRF more fully. Use of Custom Request HeadersAdding CSRF tokens, a double submit cookie and value, encrypted token, or other defense that involves changing the UI can frequently be complex or otherwise problematic. An alternate defense that is particularly well suited for AJAX/XHR endpoints is the use of a custom request header. This defense relies on the same-origin policy (SOP) restriction that only JavaScript can be used to add a custom header, and only within its origin. By default, browsers do not allow JavaScript to make cross origin requests. A particularly attractive custom header and value to use is “X-Requested-With: XMLHttpRequest” because most JavaScript libraries already add this header to requests they generate by default. However, some do not. For example, AngularJS used to, but does not anymore. For more information, see their rationale and how to add it back. If this is the case for your system, you can simply verify the presence of this header and value on all your server side AJAX endpoints in order to protect against CSRF attacks. This approach has the double advantage of usually requiring no UI changes and not introducing any server side state, which is particularly attractive to REST services. You can always add your own custom header and value if that is preferred. This defense technique is specifically discussed in section 4.3 of Robust Defenses for Cross-Site Request Forgery. However, bypasses of this defense using Flash were documented as early as 2008 and again as recently as 2015 by Mathias Karlsson to exploit a CSRF flaw in Vimeo. A Flash attack can't spoof the Origin or Referer headers, so by checking both of them we believe this combination of checks should prevent Flash bypass CSRF attacks (if any comes up in future). Besides any possible future bypasses such as Flash, using a static header will make it easy to exploit other state changing operations in the application (similar to the previous explanation on why ease of exploitation is easier in origin/referer header check than token based mitigation). Including a random token instead of static header value is more or less equal to the token based approach described in the Primary Defenses section. Developers also need to consider that if you are using this approach in an application with both Ajax calls and form tags, this technique would only help Ajax calls in protecting from CSRF and you would still need protect <form> tags with approaches described in this document such as tokens. Setting custom headers on form tags is not possible directly. Also, CORS configuration should also be robust to make this solution work effectively (as custom headers for requests coming from other domains trigger a pre-flight CORS check). User Interaction Based CSRF DefenseWhile all the techniques referenced here do not require any user interaction, sometimes it’s easier or more appropriate to involve the user in the transaction to prevent unauthorized operations (forged via CSRF or otherwise). The following are some examples of techniques that can act as strong CSRF defense when implemented correctly.
While these are a very strong CSRF defense, it does create a huge impact on the user experience. For applications that are in need of high security for some operations (password change, money transfer etc.), these techniques should be used along with token based mitigation. Please note that tokens by themselves can mitigate CSRF, developers should use these techniques only to achieve additional security for their high sensitive operations. Not So Popular CSRF MitigationsTriple Submit CookieThis mitigation is proposed by John Wilander in 2012 at OWASP Appsec Research. This technique adds an additional step to double submit cookie approach by verifying if the request contains two cookies with same name (please note, attacker need to write an additional cookie to bypass double submit cookie mitigation). Though it mitigates the issues discussed in bypass of double submit cookie, it introduces new problems such as cookie jar overflow (in-details and more issue details here and here). We were not able to find any real-time implementations of this mitigation so far. Content-Type Header ValidationThis technique is better known than the triple submit cookie mitigation. In first place, this header is not designed for security (initial RFC here and later well-defined in this RFC) but only to let receiving agents know the type of data they would be handling, so that they can invoke corresponding parsers. The pre-flighting behavior of this header (pre-flight if header has value other than application/x-www-form-urlencoded, multipart/form-data, or text/plain) is what treated as a CSRF mitigation and thus forcing all requests to have a header value that would force a pre-flight (such as application/json. Server side can reject cross-origin requests with CORS/SOP during this pre-flight). This approach has two main problems. One that it would mandate all requests to have a header value that would force pre-flight despite the real use case and the other that this technique is relying on a feature that is not designed for security, to mitigate a security vulnerability. When a bug was discovered in the Chrome API, browser architects even considered to removing this pre-flighting behavior. Because this header was not designed as a security control, architects can re-design it to better cater its primary purpose. In the future, there’s a possibility that new content-type header types can be included (to better support various use-cases), which can put systems relying on this header for CSRF mitigation in trouble. For more information, see Common CSRF Prevention Misconceptions. CSRF Mitigation MythsThe following shows techniques presumed to be CSRF mitigations but none of them fully/actually mitigates a CSRF vulnerability.
Personal Safety CSRF Tips for UsersSince CSRF vulnerabilities are reportedly widespread, we recommend using the following best practices to mitigate risk.
Integrated HTML-enabled mail/browser and newsreader/browser environments pose additional risks since simply viewing a mail message or a news message might lead to the execution of an attack. Implementation reference exampleThe following JEE web filter provides an example reference for some of the concepts described in this cheat sheet. It implements the following stateless mitigations (OWASP CSRFGuard, cover a stateful approach).
Please note that it only acts a reference sample and is not complete (for example: it doesn’t have a block to direct the control flow when origin and referer header check succeeds nor it has a port/host/protocol level validation for referer header). Developers are recommended to build their complete mitigation on top of this reference sample. Developers should also implement standard authentication or authorization checks before checking for CSRF. Source is also located here and provides a runnable POC. import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import javax.xml.bind.DatatypeConverter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.SecureRandom;
import java.util.Arrays;
/**
* Filter in charge of validating each incoming HTTP request about Headers and CSRF token.
* It is called for all requests to backend destination.
*
* We use the approach in which:
* - The CSRF token is changed after each valid HTTP exchange
* - The custom Header name for the CSRF token transmission is fixed
* - A CSRF token is associated to a backend service URI in order to enable the support for multiple parallel Ajax request from the same application
* - The CSRF cookie name is the backend service name prefixed with a fixed prefix
*
* Here for the POC we show the "access denied" reason in the response but in production code only return a generic message !
*
* @see "https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)_Prevention_Cheat_Sheet"
* @see "https://wiki.mozilla.org/Security/Origin"
* @see "https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie"
* @see "https://chloe.re/2016/04/13/goodbye-csrf-samesite-to-the-rescue/"
*/
@WebFilter("/backend/*")
public class CSRFValidationFilter implements Filter {
/**
* JVM param name used to define the target origin
*/
public static final String TARGET_ORIGIN_JVM_PARAM_NAME = "target.origin";
/**
* Name of the custom HTTP header used to transmit the CSRF token and also to prefix
* the CSRF cookie for the expected backend service
*/
private static final String CSRF_TOKEN_NAME = "X-TOKEN";
/**
* Logger
*/
private static final Logger LOG = LoggerFactory.getLogger(CSRFValidationFilter.class);
/**
* Application expected deployment domain: named "Target Origin" in OWASP CSRF article
*/
private URL targetOrigin;
/***
* Secure generator
*/
private final SecureRandom secureRandom = new SecureRandom();
/**
* {@inheritDoc}
*/
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
HttpServletRequest httpReq = (HttpServletRequest) request;
HttpServletResponse httpResp = (HttpServletResponse) response;
String accessDeniedReason;
/* STEP 1: Verifying Same Origin with Standard Headers */
//Try to get the source from the "Origin" header
String source = httpReq.getHeader("Origin");
if (this.isBlank(source)) {
//If empty then fallback on "Referer" header
source = httpReq.getHeader("Referer");
//If this one is empty too then we trace the event and we block the request (recommendation of the article)...
if (this.isBlank(source)) {
accessDeniedReason = "CSRFValidationFilter: ORIGIN and REFERER request headers are both absent/empty so we block the request !";
LOG.warn(accessDeniedReason);
httpResp.sendError(HttpServletResponse.SC_FORBIDDEN, accessDeniedReason);
return;
}
}
//Compare the source against the expected target origin
URL sourceURL = new URL(source);
if (!this.targetOrigin.getProtocol().equals(sourceURL.getProtocol()) || !this.targetOrigin.getHost().equals(sourceURL.getHost())
|| this.targetOrigin.getPort() != sourceURL.getPort()) {
//One the part do not match so we trace the event and we block the request
accessDeniedReason = String.format("CSRFValidationFilter: Protocol/Host/Port do not fully matches so we block the request! (%s != %s) ",
this.targetOrigin, sourceURL);
LOG.warn(accessDeniedReason);
httpResp.sendError(HttpServletResponse.SC_FORBIDDEN, accessDeniedReason);
return;
}
/* STEP 2: Verifying CSRF token using "Double Submit Cookie" approach */
//If CSRF token cookie is absent from the request then we provide one in response but we stop the process at this stage.
//Using this way we implement the first providing of token
Cookie tokenCookie = null;
if (httpReq.getCookies() != null) {
String csrfCookieExpectedName = this.determineCookieName(httpReq);
tokenCookie = Arrays.stream(httpReq.getCookies()).filter(c -> c.getName().equals(csrfCookieExpectedName)).findFirst().orElse(null);
}
if (tokenCookie == null || this.isBlank(tokenCookie.getValue())) {
LOG.info("CSRFValidationFilter: CSRF cookie absent or value is null/empty so we provide one and return an HTTP NO_CONTENT response !");
//Add the CSRF token cookie and header
this.addTokenCookieAndHeader(httpReq, httpResp);
//Set response state to "204 No Content" in order to allow the requester to clearly identify an initial response providing the initial CSRF token
httpResp.setStatus(HttpServletResponse.SC_NO_CONTENT);
} else {
//If the cookie is present then we pass to validation phase
//Get token from the custom HTTP header (part under control of the requester)
String tokenFromHeader = httpReq.getHeader(CSRF_TOKEN_NAME);
//If empty then we trace the event and we block the request
if (this.isBlank(tokenFromHeader)) {
accessDeniedReason = "CSRFValidationFilter: Token provided via HTTP Header is absent/empty so we block the request !";
LOG.warn(accessDeniedReason);
httpResp.sendError(HttpServletResponse.SC_FORBIDDEN, accessDeniedReason);
} else if (!tokenFromHeader.equals(tokenCookie.getValue())) {
//Verify that token from header and one from cookie are the same
//Here is not the case so we trace the event and we block the request
accessDeniedReason = "CSRFValidationFilter: Token provided via HTTP Header and via Cookie are not equals so we block the request !";
LOG.warn(accessDeniedReason);
httpResp.sendError(HttpServletResponse.SC_FORBIDDEN, accessDeniedReason);
} else {
//Verify that token from header and one from cookie matches
//Here is the case so we let the request reach the target component (ServiceServlet, jsp...) and add a new token when we get back the bucket
HttpServletResponseWrapper httpRespWrapper = new HttpServletResponseWrapper(httpResp);
chain.doFilter(request, httpRespWrapper);
//Add the CSRF token cookie and header
this.addTokenCookieAndHeader(httpReq, httpRespWrapper);
}
}
}
/**
* {@inheritDoc}
*/
@Override
public void init(FilterConfig filterConfig) throws ServletException {
//To easier the configuration, we load the target expected origin from an JVM property
//Reconfiguration only require an application restart that is generally acceptable
try {
this.targetOrigin = new URL(System.getProperty(TARGET_ORIGIN_JVM_PARAM_NAME));
} catch (MalformedURLException e) {
LOG.error("Cannot init the filter !", e);
throw new ServletException(e);
}
LOG.info("CSRFValidationFilter: Filter init, set expected target origin to '{}'.", this.targetOrigin);
}
/**
* {@inheritDoc}
*/
@Override
public void destroy() {
LOG.info("CSRFValidationFilter: Filter shutdown");
}
/**
* Check if a string is null or empty (including containing only spaces)
*
* @param s Source string
* @return TRUE if source string is null or empty (including containing only spaces)
*/
private boolean isBlank(String s) {
return s == null || s.trim().isEmpty();
}
/**
* Generate a new CSRF token
*
* @return The token a string
*/
private String generateToken() {
byte[] buffer = new byte[50];
this.secureRandom.nextBytes(buffer);
return DatatypeConverter.printHexBinary(buffer);
}
/**
* Determine the name of the CSRF cookie for the targeted backend service
*
* @param httpRequest Source HTTP request
* @return The name of the cookie as a string
*/
private String determineCookieName(HttpServletRequest httpRequest) {
String backendServiceName = httpRequest.getRequestURI().replaceAll("/", "-");
return CSRF_TOKEN_NAME + "-" + backendServiceName;
}
/**
* Add the CSRF token cookie and header to the provided HTTP response object
*
* @param httpRequest Source HTTP request
* @param httpResponse HTTP response object to update
*/
private void addTokenCookieAndHeader(HttpServletRequest httpRequest, HttpServletResponse httpResponse) {
//Get new token
String token = this.generateToken();
//Add cookie manually because the current Cookie class implementation do not support the "SameSite" attribute
//We let the adding of the "Secure" cookie attribute to the reverse proxy rewriting...
//Here we lock the cookie from JS access and we use the SameSite new attribute protection
String cookieSpec = String.format("%s=%s; Path=%s; HttpOnly; SameSite=Strict", this.determineCookieName(httpRequest), token, httpRequest.getRequestURI());
httpResponse.addHeader("Set-Cookie", cookieSpec);
//Add cookie header to give access to the token to the JS code
httpResponse.setHeader(CSRF_TOKEN_NAME, token);
}
}Authors and Primary EditorsManideep Konakandla (Amazon Application Security Team) - http://www.manideepk.com Dave Wichers - dave.wichers[at]owasp.org Paul Petefish - https://www.linkedin.com/in/paulpetefish Eric Sheridan - eric.sheridan[at]owasp.org Dominique Righetto - dominique.righetto[at]owasp.org Other Cheat Sheets |
