To start with, a quick recap on what Cross-Site Request Forgery is:
- User is logged into their bank’s website:
- The bank website has a “money transfer” function:
- The “money transfer” function accepts the following POST parameters:
- While logged into
https://example.comthe user receives an email from a person they think is their friend.
- The user clicks the link inside the email to access a cat video:
cats.htmwhilst displaying said cat video, also makes a client-side AJAX request to
https://example.com/manage_money/transfer.doPOSTing the values
amount=100transferring £100 to the attacker’s account from the victim.
There’s a common misconception that websites can’t make cross-domain requests to other domains due to the Same Origin Policy. This could be due to the following being displayed within the browser console:
However, this is not the case. The request has been made, the browser message is telling you that the current origin (
https://attacker-site.co.uk) simply cannot read any of the returned data from the cross-domain request. However, unlike an XSS attack, it doesn’t need to. The request has been made, and because the user is logged into the bank so therefore has a session cookie, this session cookie has been passed to the bank site authorising the transaction.
Simulate the bank issuing a session cookie by creating our own in the browser:
Note we’ll set the Secure flag and HTTPOnly flags to show these have no effect on CSRF.
Visit the website:
The following request is sent, note our session cookie is included:
Therefore as far as the web application is concerned, this is a legitimate request from the user to transfer the money despite the browser returning
Cross-Origin Request Blocked. Only the response is blocked, not the original request.
If the target application has no CSRF mitigation in place, the above works for both AJAX requests and traditional form POSTs. This can be mitigated using the traditionally recommended Synchronizer Token Pattern. This involves creating a random, unpredictable token (in addition to the session token held in the cookie) and storing this server-side as a session variable. When a POST is made, this anti-CSRF token is also sent, but using any mechanism apart from cookies. This means that the anti-CSRF token will not be automatically included from the browser should the user follow a dodgy link that makes its own cross-domain request. CSRF averted.
But what if there was another way? One little known way is to include a custom header, such as
X-Requested-With, as I answered here.
- Set the custom header in every AJAX request that changes server-side state of the application. e.g.
- In each server-side method handler, ensure a CSRF check function is called.
- The CSRF function examines the HTTP request and checks that
X-Requested-With: XmlHttpRequestis present as a header.
- If it is, it is allowed. If it isn’t, send an HTTP 403 response and log this server-side.
- Any attempt to do so with a modern browser will trigger a CORS preflight request.
- Older browsers (think IE 8 and 9) can send cross-domain requests, but custom headers are not supported at all.
- Very old browsers cannot send cross-domain AJAX requests at all.
What is a Preflight?
So referring to the above old browsers couldn’t make cross-domain requests at all via AJAX. Therefore, you may get an old website that does check for a custom header server-side so that it knows it is an AJAX request. Now, the web is developed on the basis of “no breaking changes”. Therefore any new technologies introduced into the browser should not force websites to have to update themselves to continue working (why not visit the World Wide Web - apparently the world’s first website). This goes for functionality as well as security.
Therefore, suddenly allowing browsers to send cross-domain headers could break security if a site relies on this for CSRF mitigation. This scenario covers both points 2 and 3.
So that leaves 1, CORS (Cross-Origin Resource Sharing). CORS is a mechanism that weakens security. Its aim is to allow sites that trust one another to break the Same Origin Policy and read each others responses. e.g.
api.example.org might allow
example.org to make a cross-domain request and read the response in the browser, using the user’s session cookie as authorisation.
In a nutshell CORS does not prevent anything that used to be possible from happening. An example is a cross domain post using
<form method="post"> has always been allowed, so therefore CORS allows any AJAX request that results in a previously possible HTTP request to be made, without a preflight request. This is because this has always been possible on the web and allowing AJAX to do this as well does not introduce any extra risk. However, a request with custom headers causes the browser to automatically send a request to the endpoint using the
OPTIONS verb. If the server-side application recognises the
OPTIONS request (i.e. it is CORS aware), it will reply with a header showing which headers will be allowed from the calling domain.
Here you can see the attempt to send
X-Requested-With in a cross-domain POST results in an OPTIONS request requesting this header be allowed, rather than the actual request. This is the preflight.
If the server-side is not explicitly configured to allow this (i.e. no
Access-Control-Allow-Origin to allow the domain and no
Access-Control-Allow-Headers to allow the custom header):
The header is not allowed because our
example.com domain is not configured for CORS.
Therefore if CORS is not allowing the attacker’s domain to send extra headers, this mitigates CSRF.
Will This Work?
What To Look For When Pentesting
The above will only work if the server-side application is verifying that the custom header
X-Requested-With is received in the request. As a pentester you should verify that all potentially discovered CSRF vulnerabilities are actually exploitable. Burp Suite allows this via right clicking an item then clicking
Engagement tools > Create CSRF PoC. This may result in two things:
- If you weren’t aware of the above, you may find a POST request that first appeared vulnerable to CSRF (due to no tokens) however isn’t due to header checking.
- If, after having read this post, you find that an AJAX request is sending
X-Requested-With: XmlHttpRequestyou may find that removing this header still causes the “unsafe” action to take place server-side, therefore the request is vulnerable.
What To Do As A Developer
This may be a good short-cut if your server-side language of choice does not support server-side variables or if you do not want the extra overhead of storing an additional token per user session. However, make sure that the presence of the HTTP request header is verified for every handler that makes a change of state to your application. Aka, “unsafe” requests as defined by the RFC.
This is a useful, easy to implement mitigation for CSRF. Although an attacker can easily add a custom header themselves (e.g. using Burp Suite), they can only do this to their own requests, not those of the victim as required in a client-side attack. There were vulnerabilities in Flash that allowed a custom-header to be added to a cross-domain request to another attacker’s site that set
crossdomain.xml. Unlike HTML, Flash requires a
crossdomain.xml file for any request, even those that are write only, such as CSRF. The trick here was for the attacker to issue a 307 HTTP redirect to redirect from their second attacker domain to the victim website. The bug in Flash carried over the custom header from the original request. However, as Flash is moribund, and this was a bug, I would say it is generally safe for most sites to rely on the presence of the header as a mitigation. However, if the risk appetite is low for the application in question, go with token mitigation instead of or as well: Defence-In-Depth.
Note that the Flash bug was fixed back in 2015.
A site that I discovered was echoing everything on the query string and POST data into a
I’m guessing this was for debugging reasons. So an easy XSS with
So I thought rather than just echoing
xss I’d output the current cookie as a simple POC.
However, things weren’t as they seemed:
Underscore!? Oh well, I’ll just use an accessor to access the property:
So thought the answer was to host the script on a remote domain:
Doh! Two problems….
A quick Google gave the answer to use
%0C for the space:
And then to get the dots, we can simply HTML encode them as we are in an HTML context:
which percent encoded is of course
And this delivered the goods:
which the browser reads as
And dutifully delivers our message box:
…and why you should report it (maybe).
This post is regarding the .NET Request Validation vulnerability, as described here. Note that this is nothing new, but I am still finding the issue prevalent on .NET sites in 2017.
Request Validation is an ASP.NET input filter.
This is designed to protect applications against XSS, even though Microsoft themselves state that it is not secure:
Even if you’re using request validation, you should HTML-encode text that you get from users before you display it on a page.
To me, that seems a bit mad. If you are providing users of your framework with functionality that mitigates XSS, why do users then have to do the one thing that mitigates XSS themselves?
Microsoft should have ensured that all .NET controls properly output things HTML encoded. For example, unless the developer manually output encodes the data in the following example then XSS will be introduced.
<asp:Repeater ID="Repeater2" runat="server"> <ItemTemplate> <%# Eval("YourField") %> </ItemTemplate> </asp:Repeater>
<%: syntax introduced in .NET 4 was a good move for automatic HTML encoding, although it should have existed from the start.
Now to summarise, normally ASP.NET Request Validation blocks any HTTP request that appears to contain tags. e.g.
example.com/?foo=<b> would result in
A potentially dangerous Request.QueryString value was detected from the client error, presented on a nice Yellow Screen of Death.
This is to prevent a user from inserting a
<script> tag into user input, or from trying some other form such as
<svg onload="alert(1)" />.
However, the flaw in this is that
<%tag is allowed. This is a quirky tag that only works in Internet Explorer 9.
But ironically not quirks mode, it requires IE9 standards mode so the top of the page must contain this Edit: It works in either mode, however if the page is in quirks mode then it requires user interaction (like mouseover). Example, the existing page can seen to be in quirks mode as it contains the following type definition and meta tag (although in tests only the meta tag seems to be required):
<!doctype html> <meta http-equiv="X-UA-Compatible" content="IE=Edge">
<!doctype html> <html> <head> <meta http-equiv="X-UA-Compatible" content="IE=Edge"> </head> <body> <%tag onmouseover="alert('markitzeroday.com')">Move mouse here </body> </html>
Loading your target page in Internet Explorer 9 and then viewing developer tools will show you whether the page is rendered in quirks mode.
Edit: Actually this does work in quirks mode too using a CSS vector and no document type declaration:
<html> <head> </head> <body> <%tag style="xss:expression(alert('markitzeroday.com'))">And you don't even have to mouseover </body> </html>
Example Warning: This is a trap, and you may need to hold escape to well… escape.
Note that it is important that this is reported, even though it affects Internet Explorer 9 only. The reasons are as follows:
- Some organisations are “stuck” on old versions of Internet Explorer for compatibility reasons. Their IT department will not upgrade the browsers network wide as a piece of software bought in 2011 for £150,000 will not run on anything else.
- By getting XSS with one browser version, you are proving that adequate output encoding is not in place. This shows the application is vulnerable should it also use data from other sources. e.g. User input from a database shared with a non ASP.NET app, or an app that is written properly as not to rely on ASP.NET Request Validation.
- Granted you can only test inputs from your “in-scope” applications and prove that those inputs have a vulnerable sink when output elsewhere, although chances are that if one part of the application is vulnerable then other parts will be and you can alert your client to this possibility quite literally.
Note also that Request Validation inhibits functionality. Much like my post on functional flaws vs security flaws, preventing a user from entering certain characters and then resolving this by issuing an HTTP 500 response results in a broken app. If such character sequences are not allowed, you should alert the user in a friendly way and give them chance to fix it first, even if this is only client-side validation. Also any automated processes that may include
<stuff that it POSTs or GETs to your application may unexpectedly fail.
The thing that Microsoft got wrong with Request Validation is that XSS it an output problem, not an input problem. The Microsoft article linked above is still confused about this:
Of course, if you want a highly secure site as your risk appetite is low, then do validate user input. Don’t let non alphanumeric characters be entered if they are not needed. However, the primary mitigation for XSS is output encoding. This is the act of changing characters like
<. Then it doesn’t matter if this is output to your page as the browser won’t execute it and therefore no XSS.
On a web test once I was having trouble finding any instances of cross-site scripting, which is very unusual.
However, after scanning the site with nikto, some interesting things came up:
$ nikto -h rob-sec-1.com - ***** RFIURL is not defined in nikto.conf--no RFI tests will run ***** - Nikto v2.1.5 --------------------------------------------------------------------------- + Target IP: 188.8.131.52 + Target Hostname: rob-sec-1.com + Target Port: 80 + Start Time: 2018-02-03 15:37:18 (GMT0) --------------------------------------------------------------------------- + Server: Apache + The anti-clickjacking X-Frame-Options header is not present. + Cookie v created without the httponly flag + Root page / redirects to: /?node_id=V0lMTCB5b3UgYmUgcmlja3JvbGxlZD8%3D + Server leaks inodes via ETags, header found with file /css, inode: 0x109c8, size: 0x56, mtime: 0x543795d00f180;56450719f9b80 + Uncommon header 'tcn' found, with contents: choice + OSVDB-3092: /css: This might be interesting... + OSVDB-3092: /test/: This might be interesting... + OSVDB-3233: /icons/README: Apache default file found. + 4197 items checked: 0 error(s) and 7 item(s) reported on remote host + End Time: 2018-02-03 15:40:15 (GMT0) (177 seconds) --------------------------------------------------------------------------- + 1 host(s) tested
+ OSVDB-3092: /test/: This might be interesting...
So I navigated to
/test/ and saw this at the top of the page:
So the page had the usual content, however, there appeared to be some odd text at the top, and because it said
NULL this struck me as some debug output that the developers had left in on the production site.
So to find out if this debug output is populated by any query string parameter, we can use wfuzz.
First we need to determine how many bytes come back from the page on a normal request:
$curl 'http://rob-sec-1.com/test/?' 1>/dev/null % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 53 100 53 0 0 53 0 0:00:01 --:--:-- 0:00:01 289
Here we can see that this is 53. From there, we can configure wfuzz to try different parameter names and then look for any responses that have a size other than 53 characters. Here we’ll use dirb’s common.txt list as a starting point:
$ wfuzz -w /usr/share/wordlists/dirb/common.txt --hh 53 'http://rob-sec-1.com/test/?FUZZ=<script>alert("xss")</script>' ******************************************************** * Wfuzz 2.2.3 - The Web Fuzzer * ******************************************************** Target: HTTP://rob-sec-1.com/test/?FUZZ=<script>alert("xss")</script> Total requests: 4614 ================================================================== ID Response Lines Word Chars Payload ================================================================== 02127: C=200 9 L 8 W 84 Ch "item" Total time: 14.93025 Processed Requests: 4614 Filtered Requests: 4613 Requests/sec.: 309.0369
Well, whaddya know, looks like we’ve found the parameter!
/test/?item=<script>alert("xss")</script> into Firefox gives us our alert:
Two important headers that can mitigate XSS are:
So what is the difference?
Well browsers such as Internet Explorer and Chrome include an “XSS auditor” which attempts to help prevent reflected XSS from firing. The first header controls that within the browser.
Details are here, but basically the four supported options are:
X-XSS-Protection: 0 X-XSS-Protection: 1 X-XSS-Protection: 1; mode=block X-XSS-Protection: 1; report=<reporting-uri>
It should be noted that the auditor is active by default, unless the user (or their administrator) has disabled it.
will turn it back on for the user.
What I wanted to show you was the difference between specifying
block, and either not including the header at all (which therefore will take on the setting in the browser) or specifying
block. Also, for good measure I will show you the Content Security Policy mitigation for cross-site scripting.
I will show you a way that if a site has specified
block, how this can be abused.
The linked page has the following code in it:
<script>document.write("one potato")</script><br /> <script>document.write("two potato")</script><br /> three potato
Now if we link straight there from the current page you’re reading, the two script blocks should fire:
To demonstrate how the XSS auditors work, let’s imagine we tried to inject that script into the page ourselves by appending this query string:
?xss1=<script>document.write("one potato")</script>&xss2=<script>document.write("two potato")</script>
Note that the following will not work from Firefox, as at the time of writing Firefox doesn’t include any XSS auditor and therefore is very open to reflected XSS should the visited site be vulnerable. There is the add-on noscript that you can use to protect yourself, should Firefox be your browser of choice. Note the following has been tested in Chrome 64 only. I will also enable your XSS filter in supported browsers by adding
X-XSS-Protection: 1 to the output.
Note how the browser now thinks that the two script blocks have been injected, and therefore blocks them and only outputs the plain HTML. View source to see the code if you don’t believe it is still there.
Viewing F12 developer tools shows us the auditor has done its stuff:
Viewing source shows us which script has been blocked in red:
Now what could an attacker do to abuse the XSS auditor? Well they could manipulate the page to prevent scripts of their choosing to be blocked.
Viewing the source shows the attacker has just blocked what they wanted by specifying the source code in the URl:
Of course, editing their own link is fruitless, they would have to be passing the link onto their victim(s) in some way by sending it to via email, Facebook, Skype, etc …
What are the risks in this? Well The Web Application Hacker’s Handbook puts it better than I could:
So, how can we defend against this? Well, you guessed it, the
X-XSS-Protection: 1; mode=block
So let’s try this again with that specified:
So by specifying
block we can prevent an attacker from crafting links that neutralise our existing script!
So in summary it is always good to specify
block as by default XSS auditors only attempt to block what they think is being injected, which might not actually be the evil script itself.
Content Security Policy then?
Just to demo the difference, if we output a CSP header that prevents inline script and don’t attempt to inject anything:
Chrome shows us this is solely down to Content Security Policy:
To get round this as site developers we can either specify the SHA-256 hash as described in our CSP, or simply move our code to a separate
.js file as long as we white-list
self in our policy. Any attacker injecting inline script will be foiled. Of course the problem with Content Security Policy is that it still seems to be an after-thought and trying to come up with a policy that fits an existing site is very hard unless your site is pretty much static. However, it is a great mitigation if done properly. Any weaknesses in the policy though may be ripe for exploitation. Hopefully I’ll have a post on that in the future if I come across it in any engagements.
*Yeh yeh, you’re not using X-XSS-Protection for evil, but lack of
block of course, and if no-one has messed with the browser settings it is as though
X-XSS-Protection: 1 has been output.
…or why you should ensure all Windows machines are domain joined.
This is my first non-web post on my blog. I’m traditionally a web developer, and that is where my first interest in infosec came from. However, since I have managed to branch into penetration testing, Active Directory testing has become my favourite type of penetration test.
This post is regarding an internal network test I undertook some years back. This client’s network is a tough nut to crack, and one I’ve tested before so I was kind of apprehensive of going back to do this test for them in case I came away without having “hacked in”. We had only just managed it the previous time.
The first thing I run on an internal is the Responder tool. This will grab Windows hashes from LLMNR or NetBIOS requests on the local subnet. However, this client was wise to this and had LLMNR & NetBIOS requests disabled. Despite already knowing this fact from the previous engagement, one of the things I learned during my OSCP course was to always try the easy things first - there’s no point in breaking in through a skylight if the front door is open.
So I ran Responder, and I was surprised to see the following hash captured:
Note of course, that I would never reveal client confidential information on my blog, therefore everything you see here is anonymised and recreated in the lab with details changed.
Here we can see the host
172.16.157.133 has sent us the NETNTLMv2 hash for the account
Checking this host’s NetBIOS information with Crack Map Exec (other tools are available), we can check whether this is a local account hash. If it is, the “domain” part of the username:
[SMBv2] NTLMv2-SSP Username : 2-FD-87622\FRONTDESK
2-FD-87622 should match the host’s NetBIOS name if this is the case. Looking up the IP with CME we can see the name of the host matches:
So the next port of call we try to crack this hash and gain the plaintext password. Hashcat was loaded against rockyou.txt and rules, and quickly cracked the password.
hashcat -m 5600 responder /usr/share/wordlists/rockyou.txt -r /usr/share/rules/d3adhob0.rule
Now we have a set of credentials for the front desk machine. Hitting the machine again with CME but this time passing the cracked credentials:
cme smb 172.16.157.133 -u FRONTDESK -p 'Winter2018!' --local-auth
We can see
Pwn3d! in the output showing us this is a local administrator account. This means we have the privileges required to dump the local password hashes:
cme smb 172.16.157.133 -u FRONTDESK -p 'Winter2018!' --local-auth --sam
Note we can see
This time we are seeing the NTLM hash of the password, rather than the NETNTLMv2 “challenge/response” hash that Responder caught earlier. Responder catches hashes over the wire, and these are different to the format that Windows stores in the SAM.
The next step was to try the local administrator hash and spray it against the client’s server range. Note that we don’t even have to crack this administrator password, we can simply “pass-the-hash”:
cme smb 172.16.157.0/24 -u administrator -H 'aad3b435b51404eeaad3b435b51404ee:5509de4ff0a6eed7048d9f4a61100e51' --local-auth
We can only pass-the-hash using the stored NTLM format, not the NETNTLMv2 network format (unless you look to execute an “SMB relay” attack instead).
To our surprise, it got a hit, the local administrator password had been reused on the STEWIE machine. Querying this host’s NetBIOS info:
$ cme smb 172.16.157.134 SMB 172.16.157.134 445 STEWIE [*] Windows Server 2008 R2 Foundation 7600 x64 (name:STEWIE) (domain:MACFARLANE) (signing:False) (SMBv1:True)
We can see it is a member of the MACFARLANE domain, the main domain of the client’s Active Directory.
So the non-domain machine had a local administrator password which was reused on the internal servers. We can now use Metasploit to PsExec onto the machine, using the NTLM as the password which will cause Metasploit to pass-the-hash.
Once ran, our shell is gained:
We can load the Mimikatz module and read Windows memory to find passwords:
Looks like we have the DA (Domain Admin) account details. And to finish off, we use CME to execute commands on the Domain Controller to add ourselves as a DA (purely for a POC, in real life or to remain more stealthy we could just use the discovered account).
cme smb 172.16.157.135 -u administrator -p 'October17' -x 'net user markitzeroda hackersPassword! /add /domain /y && net group "domain admins" markitzeroda /add'
Note the use of the undocumented
/y function to suppress the prompt Windows gives you for adding a password longer than 14 characters.
A screenshot of Remote Desktop to the Domain Controller can go into the report as proof of exploitation:
So if this front desk machine had been joined to the domain, it would have had LLMNR disabled (from their Group Policy setting) and we wouldn’t have gained the initial access to it and leveraged its secrets in order to compromise the whole domain. Of course there are other mitigations such as using LAPS to manage local administrator passwords and setting
FilterAdministratorToken to prevent SMB logins using the local RID 500 account (great post on this here).