Learn how to add and manage protections for web application firewall policies.
Web Application Firewall protects your web applications against threats. Web Application Firewall is a regional-based service that is attached to an enforcement point. Use Web Application Firewall protection capabilities to protect your critical web applications against malicious cyberattacks. You can use the protection capabilities to set up rules that are compared against incoming requests to determine if the request contains an attack payload. If it is determined that a request is an attack, Web Application Firewall blocks or alerts you to that request. These attacks are varied and include threats such as SQL injection, cross-site scripting, and HTML injection—all of which the Web Application Firewall protection capabilities can detect and block.
Web Application Firewall protection is a toolkit designed for web application monitoring, logging, and access control. The toolkit lets you decide how to take advantage of all the protection capabilities available. This flexibility is a core element of Web Application Firewall protection, as OCI is constantly pushing updates to increase the security scope of protection capabilities.
The core principles of Web Application Firewall protection capabilities are:
Passiveness: You decide which capabilities are required, therefore you have full control.
Flexibility: The Oracle Web Application Firewall security team has curated a list of protection capabilities that address both Open Web Application Security Project (OWASP) top 10 and critical CVE's for popular web applications.
Quality not quantity: Web Application Firewall protection rules is a dedicated module designed to inspect HTTP traffic that works with the other WAF features (for example, access control).
Predictability: Having full control of the Web Application Firewall protection capabilities allows you to control the results expected. You can define and tune your protection rules and leave the setup unattended, knowing that it keeps working as it was configured.
Protection rules match web traffic to rule conditions and determine the action to be taken when the conditions are met.
The Web Application Firewall policy has approximately 490 rules and contains only the newest versions of the rules. WAF policy includes only rules based on CRS 3.0 and later.
Note
We continuously update and optimize existing rules, in addition to creating rules. Because of vulnerability concerns, we can't provide the mitigation pattern for rules.
Custom protection rules aren't available for the Web Application Firewall policy.
Sometimes a protection rule can trigger a false positive. You can configure an exception if
the request(s) generating the false positive have a particular argument or cookie that can be
used to identify that request be excluded from the action normally taken on the rule. You can
create exclusions using the OCI Console or through the API. Use the following exclusion
parameters:
Name
Value
REQUEST_COOKIES
Cookie Value
ARGS
Argument (Query Parameter or POST/PUT data)
Protection Capabilities Tuning 🔗
This basic WAF tuning information outlines the fundamentals of rule tuning, log inspection, and setting up capability exclusions. Tuning can be beneficial for the following reasons:
Reduces the chance of blocking a legitimate request.
Protects against standard web application attacks.
Protects against specific web application attacks.
Reduces the amount of scanning, which leads to better performance.
The following table shows protection capabilities terms and definitions.
Protection Capabilities Definitions
Term
Definition
Tuning
The process in which the customer's engineer or analyst modifies
protection capabilities and actions to allow the application server
to be protected but remain functional. There exists a balance
between locking down the application server and allowing the
application server to perform its duties. The best tuning takes an
intimate knowledge of the application server being protected and
protection capabilities available to protect that application
server.
False positive
A false positive occurs when a protection capability is matched
against an HTTP transaction and the HTTP transaction is a legitimate
(non-malicious) transaction.
Exclusion
A modification to a protection capability that allows the value or
value name of a cookie or HTTP argument to be ignored.
Collaborative Protection Capabilities 🔗
You can use special protection capabilities tagged as "collaborative" to limit false positives. The collaborative capabilities operate differently from the other protection capabilities.
Collaborative protection capabilities use a scoring and threshold system to evaluate traffic. Individual capabilities work by matching elements of the HTTP transaction and the capability signature. If a match is made, the rule performs its action (for example, detecting or blocking).
Each of the collaborative capabilities uses a group of individual capabilities. The collaborative protection capabilities require multiple matches of elements of the HTTP transaction with individual rules to perform their actions.
For collaborative capabilities to perform their actions, elements of the HTTP transaction must match the individual capabilities in the collaborative group, related to the weight versus thresholds being set on the collaborative capabilities, as follows:
Weight: A number representing how much an individual capability contributes toward the collaborative capability threshold.
Threshold: The minimum sum of weights from individual capabilities that the collaborative capability matches.
Note
You can change the weight and threshold values as needed.
When an exclusion is added within the collaborative protection capability, the exclusion applies to all individual capabilities within the collaborative capability.
Example
A collaborative capability key with ID 9420000 - SQL Injection (SQLi) Collaborative Group - SQLi Filters Categories checks the incoming HTTP request for certain types of SLQ injections. This collaborative capability is made up of several capabilities, such as 9421000, 9421400, 9421600, each with a default weight value of 4.
If this collaborative capability is enabled (9420000), for every incoming HTTP request, WAF runs each individual capability (9421000, 9421400, 9421600) that makes up the collaborative capability separately, to find matched capabilities.
After the rules are processed, the matched capabilities are used, their weights are added (in this case is 4+4+4 = 12), and the sum is checked against the threshold (10). Because the HTTP request matched the individual capabilities that make up the collaborative capability (9420000), the collaborative capability is marked as triggered. If logging is configured, the matched capability is logged. Depending on how the capability is configured, an HTTP response is returned.
The following list provides protection capabilities that are "noisy," with some descriptions and recommendations to help you understand what the capability is trying to match. Exclusions cannot be applied to some of these keys.
Capability Key
Capability Name
Notes
920310
920311
Missing Accept Header
Even when requests without accept headers do not mean a violation of the HTTP protocol, requests without accept headers are most often not genuine requests.
The rule might be alerting for API or custom application requests.
To avoid scanning API or custom application requests, collect a list of the well-known applications that send traffic through and request custom rules.
For more information, see RFC 7231, section-5.3.2.
920280
Missing Host Header
As described in RFC 7230, section-5.4 "A server must respond with a 400 (Bad Request) status code to any HTTP/1.1 request message that lacks a Host header field and to any request message that contains more than one Host header field or a Host header field with an invalid field-value." This is an essential method of protection and at the same time ensures that WAF servers properly identify which WAF policy the request is intended for. Since WAF requires a host header to pass traffic to the proper origin, this rule might cause a high rate of false positives.
920320
920330
Missing User-Agent Header
This rule prevents unidentified users from accessing your web application. User-Agent is one of the request headers defined in various RFCs that provides user information. Even when a request contains a user agent, it does not imply it comes from a real human. This rule works as a first level of mitigation for "dummy" attacks that originate from possible bots or "non-RFC compliant" applications.
Note: Some APIs might not include the User-Agent header. If API requests are expected, ensure you add the API IP address to the allowlist or have a custom WAF rule that excludes this traffic from being inspected.
For more information, see RFC 7231, section-5.5.3.
This rule is an indicator of bad or malicious traffic, but it is possible legitimate applications do not have a User-Agent. Ask application owners to use User-Agents when applicable.
920170
920171
GET/HEAD Requests Validation
As described in RFC 7231, section-4.3.1 and section-4.3.2, HEAD and GET are HTTP methods intended to retrieve information from the origin server. Even when not forbidden by the RFC, sending body or payload through these types of methods is not a common practice. Usually it is caused by improperly defined applications not following the best practices of the RFC and can be used by malicious users as a bypass technique.
It is also defined in RFC 2616, section-4.3 "if the request method does not include defined semantics for an entity-body, then the message-body should be ignored when handling the request."
920180
Missing Content-Type Header
As defined under RFC 2616, section-7.2.1, "Any HTTP/1.1 message containing an entity-body should include a Content-Type header field defining the media type of that body." If this best practice is not followed, it could lead to MIME-type sniffing attacks.
911100
Allowed HTTP methods
The default allowed HTTP methods are GET, HEAD, POST, and OPTIONS.
OPTIONS is known as an insecure method because it is highly used by attackers to gather up information from the origin server. This method is also required by some applications to work properly.
If this method is not required, create a service request with My Oracle Support to disable it.
Other methods can also be added as required with a service request.
920380
Max amount of arguments
RFC does not enforce the number of arguments that a request must have, but using many arguments could be a method used by malicious users attempting to overflow a web application.
To protect against these types of attacks, we recommend limiting the maximum number of ARGs allowed per request.
The default value is 255.
920370
Max length of an argument
RFC does not enforce the length per argument that a request must have, but using large argument length could be a method used by malicious users attempting to overflow a web application.
To protect against these types of attacks, we recommend limiting the maximum length of ARGs allowed per request.
The default value is 400.
920390
Max total argument length
RFC does not enforce the total (combined) argument size that a request must have, but large combined argument values could be a method used by malicious users attempting to overflow a web application.
To protect against these types of attacks, we recommend limiting the maximum combined argument value allowed per request.
The default value is 64000.
920350
Host Header Is IP Address
This rule does not usually trigger, as WAF needs a host header to send traffic to the origin.
This rule takes a long time to process if there is a large payload.
For example, a payload with 64,005 bytes takes around 32 seconds to process.
Protection Rules 🔗
Protection rules match web traffic to rule conditions and determine the action to be taken when the conditions are met.
WAF policy has approximately 490 rules and contains only the newest versions of the rules. WAF policy includes only rules based on CRS 3.0 and later.
Note
We continuously update and optimize existing rules, in addition to creating rules. Because of vulnerability concerns, we can't provide the mitigation pattern for rules.
Custom protection rules aren't available for WAF policy.
The following table lists protection capabilities supported by WAF. For the most up-to-date listing, view the Web Application Firewall protection capabilities in the OCI Console. See Listing Web Application Firewall Protection Capabilities.
Capability Key
Version
Name
Description
944300
1
Java attack Attempt: Interesting keywords for possibly RCE on vulnerable classes and methods base64 encoded
Java attack Attempt: Interesting keywords for possibly RCE on vulnerable classes and methods base64 encoded
Java attack Attempt: Detecting possible base64 text to match encoded magic bytes \xac\xed\x00\x05 with padding encoded in base64 strings are rO0ABQ KztAAU Cs7QAF
Java attack Attempt: Detecting possible base64 text to match encoded magic bytes \xac\xed\x00\x05 with padding encoded in base64 strings are rO0ABQ KztAAU Cs7QAF
944200
1
Java attack Attempt: Detect exploitation of "Java deserialization" Apache Commons
Java attack Attempt: Detect exploitation of "Java deserialization" Apache Commons
944152
1
Log4J / Log4Shell Defense
This rule addresses exploits against the Log4J library described in several CVEs. It checks for existence of `${`.
944151
1
Log4J / Log4Shell Defense
Log4J / Log4Shell Defense: This rule addresses exploits against the Log4J library described in several CVEs.
944150
1
Log4J / Log4Shell Defense
This rule addresses exploits against the Log4J library described in several CVEs. It detects Nested use of ${, use of ${jndi:... without the closing bracket.
944140
1
Java Script Uploads: Block file uploads with filenames ending in Java scripts
Java Script Uploads: Block file uploads with filenames ending in Java scripts (.jsp, .jspx), scan nonstandard request headers
944130
2
Java attack Attempt: Apache Struts and Oracle WebLogic vulnerabilities
Java attack Attempt: Apache Struts and Oracle WebLogic vulnerabilities
944110
944120
1
Java attack Attempt: Apache Struts and Oracle WebLogic vulnerabilities and detect processbuilder or runtime calls
SQL Injection (SQLi) Restricted SQL Character Anomaly Detection
SQL Injection (SQLi) Attempt: Restricted SQL Character Anomaly Detection also detects CVE-2018-2380
942431
1
SQL Injection (SQLi) Restricted SQL Character Anomaly Detection
SQL Injection (SQLi) Attempt: Restricted SQL Character Anomaly Detection also detects CVE-2018-2380
942430
1
SQL Injection (SQLi) Restricted SQL Character Anomaly Detection
SQL Injection (SQLi) Attempt: This rules attempts to gauge when there is an excessive use of meta-characters within a single parameter payload. Also detects CVE-2018-2380
942421
1
SQL Injection (SQLi) SQL Injection Character Anomaly Usage
SQL Injection (SQLi) Attempt: Detects SQL Injection Character Anomaly Usage
942420
1
SQL Injection (SQLi) SQL Injection Character Anomaly Usage
SQL Injection (SQLi) Attempt: Detects when there is an excessive use of meta-characters within a single parameter payload.
942410
2
SQL Injection (SQLi) SQL injection
SQL Injection (SQLi) Attempt: SQL injection detection also detects CVE-2018-2380
SQL Injection (SQLi) Attempt: chained SQL injection attempts detection, also triggers SAP CRM Java vulnerability CVE-2018-2380
942200
2
SQL Injection (SQLi) MySQL comment-/space-obfuscated injections and backtick termination
SQL Injection (SQLi) Attempt: MySQL comment-/space-obfuscated injections and backtick termination detection and also triggers SAP CRM Java vulnerability CVE-2018-2380
942190
2
SQL Injection (SQLi) MSSQL code execution and info gathering
SQL Injection (SQLi) Attempt: MSSQL code execution and info gathering detection
Cross-Site Scripting (XSS) Attempt: XSS Filters - Category 4. XSS vectors making use of javascript URI and tags, e.g., <p style="background:url(javascript:alert(1))">
Detects generic Remote Code Executions on Insecure unserialiazation. Detects CVE-2017-5941
933210
2
PHP Injection Attacks: PHP Functions - Variable Function Prevent Bypass
PHP Injection Attacks: PHP Functions - Variable Function Calls, This rule blocks bypass filter payloads.
933200
1
PHP Injection Attacks: PHP Wrappers
PHP Injection Attacks: PHP Wrappers, PHP comes with many built-in wrappers for various URL-style protocols for use with the filesystem functions such as fopen(), copy(), file_exists() and filesize(). Abusing of PHP wrappers like phar://, zlib://, glob://, rar://, zip://, etc... could lead to LFI and expect:// to RCE.
933190
1
PHP Injection Attacks: PHP Closing Tag Found
PHP Injection Attacks: PHP Closing Tag Found.
933180
2
PHP Injection Attacks: PHP Functions - Variable Function Calls
PHP Injection Attacks: PHP Functions - Variable Function Calls, PHP 'variable functions' provide an alternate syntax for calling PHP functions. An attacker may use variable function syntax to evade detection of function names during the exploitation of a remote code execution vulnerability.
933170
2
PHP Injection Attacks: PHP Object Injection
PHP Injection Attacks: PHP Object Injection, is an application-level vulnerability that could allow an attacker to perform different kinds of malicious attacks, such as Code Injection, SQL Injection, Path Traversal and Application Denial of Service, depending on the context. The vulnerability occurs when user-supplied input is not properly sanitized before being passed to the unserialize() PHP function.
933161
2
PHP Injection Attacks: PHP Functions - Low-Value PHP Function Calls
PHP Injection Attacks: PHP Functions - Low-Value PHP Function Calls. Most of these function names are likely to cause false positives in natural text or common parameter values, such as 'abs', 'copy', 'date', 'key', 'max', 'min'. Therefore, these function names are not scanned in lower paranoia levels or if high false positives are expected.
933160
2
PHP Injection Attacks: High-Risk PHP Function Calls
PHP Injection Attacks: High-Risk PHP Function Calls, some PHP function names have a certain risk of false positives, due to short names, full or partial overlap with common natural language terms, uses in other contexts, et cetera. Some examples are 'eval', 'exec', 'system'.
933151
3
PHP Injection Attacks: Medium-Risk PHP Function Names
PHP Injection Attacks: Medium-Risk PHP Function Names, Medium-Risk PHP injection payloads, and extremely rare in natural language or other contexts. This includes most PHP functions and keywords.
933150
3
PHP Injection Attacks: High-Risk PHP Function Names
PHP Injection Attacks: High-Risk PHP Function Names, Approx. 40 words highly common to PHP injection payloads and extremely rare in natural language or other contexts. Examples: 'base64_decode', 'file_get_contents'.
933140
2
PHP Injection Attacks: PHP I/O Streams
PHP Injection Attacks: Variables Found. The "php://" syntax can be used to refer to various objects, such as local files (for LFI), remote urls (for RFI), or standard input/request body. Its occurrence indicates a possible attempt to either inject PHP code or exploit a file inclusion vulnerability in a PHP web app.
933131
2
PHP Injection Attacks: PHP Variables - Common Variable Indexes
PHP Injection Attacks: PHP Script Uploads - Superfluous extension. Block file uploads with PHP extensions (.php, .php5, .phtml etc) anywhere in the name, followed by a dot.
933110
2
PHP Injection Attacks: PHP Script Uploads
PHP Injection Attacks: Block file uploads with PHP extensions (.php, .php5, .phtml etc), also block files with just dot (.) characters after the extension. Many applications contain Unrestricted File Upload vulnerabilities. Attackers may use such a vulnerability to achieve remote code execution by uploading a .php file.
Some AJAX uploaders use the nonstandard request headers X-Filename, X_Filename, or X-File-Name to transmit the file name to the server scan these request headers as well as multipart/form-data file names.
933100
3
PHP Injection Attacks: PHP Open Tag Found
PHP Injection Attacks: Detects PHP open tags "<?" and "<?php". Also detects "[php]", "[/php]" and "[\php]" tags used by some applications to indicate PHP dynamic content.
9330000
2
PHP Injection Attacks Collaborative Group - PHP Filters Categories
A Remote Command Execution (RCE) could be exploited bypassing rule 930120 (OS File Access Attempt) by using wildcard characters. Consider this rule could lead to many false positives.
932180
2
Restricted File Upload
Detects attempts to upload a file with a forbidden filename. Many applications contain Unrestricted File Upload vulnerabilities. These might be abused to upload configuration files or other files that affect the behavior of the web server, possibly causing remote code execution.
932170
932171
2
GNU Bash RCE Shellshock Vulnerability (CVE-2014-6271 and CVE-2014-7169)
Detect exploitation of "Shellshock" GNU Bash RCE vulnerability. Based on ModSecurity rules created by Red Hat.
932160
3
Unix Shell Snippets Injection
Detects some common sequences found in shell commands and scripts. This rule is also triggered by an Apache Struts Remote Code Execution CVE-2017-9805, and Oracle WebLogic Remote Command Execution exploits CVE-2017-10271.
932150
3
Unix Direct Remote Command Execution
Detects Unix commands at the start of a parameter (direct RCE). Example: foo=wget%20www.example.com. This case is different from command injection (rule 93210032), where a command string is appended (injected) to a regular parameter, and then passed to a shell unescaped. This rule is also triggered by an Oracle WebLogic Remote Command Execution exploit CVE-2017-10271.
932140
2
Windows Command Shell Injection - FOR and IF commands
This rule detects Windows command shell FOR and IF commands.
932131
1
Unix Shell Script Expressions and Oneliners
Detects common Unix Shell Expressions used in Shell Scripts and Oneliners, such as "$(foo), ${foo}, <(foo), >(foo), $((foo)), among others"
932130
3
Unix Shell Script Expressions and Oneliners.
Detects common Unix Shell Expressions used in Shell Scripts and Oneliners, such as "$(foo), ${foo}, <(foo), >(foo), $((foo)), among others"
932120
3
Windows PowerShell Injection - cmdlets and options
Detect some common PowerShell commands, cmdlets, and options. These commands should be relatively uncommon in normal text, but potentially useful for code injection.
932115
3
Windows Command Injection
This rule detects Windows shell command injections (and its attempts of obfuscation and evasion). The vulnerability exists when an application executes a shell command without proper input escaping/validation. This rule is also triggered by an Oracle WebLogic Remote Command Execution exploit CVE-2017-10271.
932110
3
Windows Command Injection
This rule detects Windows shell command injections (and its attempts of obfuscation and evasion). The vulnerability exists when an application executes a shell command without proper input escaping/validation.
932106
2
Unix Command Injection
Detects several Unix command injections (and its attempts of obfuscation and evasion). The vulnerability exists when an application executes a shell command without proper input escaping/validation.
932105
3
Unix Command Injection
Detects several Unix command injections (and its attempts of obfuscation and evasion). The vulnerability exists when an application executes a shell command without proper input escaping/validation.
932101
1
Command Injection Attack
Detects Command Injection Attempts.
932100
3
Unix Command Injection
Detects several Unix command injections (and its attempts of obfuscation and evasion). The vulnerability exists when an application executes a shell command without proper input escaping/validation. This rule is also triggered by an Oracle WebLogic Remote Command Execution exploit CVE-2017-10271.
9320001
2
Remote Code Execution (RCE) Collaborative Group - Windows RCE Filter Categories
Remote Code Execution (RCE) Attempt: RCE Filters for Windows.
Remote File Inclusion (RFI). These rules look for common types of Remote File Inclusion (RFI) attack methods. Possible RFI Attack: Off-Domain Reference/Link
931120
2
Remote File Inclusion (RFI) Attempt: RFI Attack: URL Payload Used w/Trailing Question Mark Character (?)
Remote File Inclusion (RFI). These rules look for common types of Remote File Inclusion (RFI) attack methods. Possible RFI Attack: URL Payload Used w/Trailing Question Mark Character (?)
931110
3
Remote File Inclusion (RFI) Attempt: RFI Attack: Common RFI Vulnerable Parameter Name used w/URL Payload
Remote File Inclusion (RFI). These rules look for common types of Remote File Inclusion (RFI) attack methods. Possible RFI Attack: Common RFI Vulnerable Parameter Name used w/URL Payload
931100
3
Remote File Inclusion (RFI) Attempt: RFI Attack URL Parameter using IP Address
Remote File Inclusion (RFI). These rules look for common types of Remote File Inclusion (RFI) attack methods. Possible RFI Attack: URL Parameter using IP Address
930130
2
Local File Inclusion (LFI) - Restricted File Access
Local File Inclusion (LFI) Attempt: Restricted File Access
930120
2
Local File Inclusion (LFI) - OS File Access
Local File Inclusion (LFI) Attempt: OS File Access
930110
3
Local File Inclusion (LFI) - Directory Traversal - Decoded Payloads
Local File Inclusion (LFI) Collaborative Group - LFI Filter Categories
Local File Inclusion (LFI) Attempt: Directory Traversal Attacks - OS File Access.
921200
1
LDAP Injection
This is a rule trying to prevent LDAP injection.
921190
1
HTTP Splitting
This rule detect \n or \r in the REQUEST FILENAME.
921151
1
Newline in GET Args
Detect newlines in GET arguments which may point to HTTP header injection attacks.
921150
921160
2
Argument Newline Detection
Detect newlines in argument names.
921140
1
HTTP Header Injection
These rules look for Carriage Return (CR) %0d and Linefeed (LF) %0a characters, on their own or in combination with header field names. These characters may cause problems if the data is returned in a response header and interpreted by the client.
921120
921130
2
HTTP Response Splitting
Looks for CR/LF characters, may cause problems if the data is returned in a response header and may be interpreted by an intermediary proxy server and treated as two separate responses.
921110
3
HTTP Request Smuggling
Looks for CR/LF characters in combination with HTTP / WEBDAV
920521
1
Invalid Accept-Encoding Header
Detects invalid Accept-Encoding Headers
920520
1
Accept-Encoding Header Longer than 50 Characters
This rule matches against requests that have more than 50 characters in the Accept-Encoding header value.
920510
1
Invalid Cache-Control Value
Description: Rule detects invalid values in the cache-control header
920500
1
Detect backup or working files
Detect backup or working files.
920490
1
Bypass Content-Type Header with x-up-devcap-post-charset
Detection of Content-Type bypass with x-up-devcap-post-charset header
920480
1
Charset restriction in content-type
Restrict charset in Content Types by checking the variable allowed_request_content_type_charset.
920470
3
Restrict Content-Type
Restrict Content Types by checking the content-type header
920450
2
Restricted HTTP headers
The use of certain headers is restricted. They are listed in the variable restricted_headers.
920440
1
Restriction by file extension
Restrict file extensions using the variable restricted_extensions.
920430
1
Request protocol version restriction
Restrict protocol versions by using the variable allowed_http_versions.
920420
2
Check content-type header against allow list
Restrict Content Types by checking the variable allowed_request_content_type.
920410
1
Limit combined file size
Limits the size of combined files by checking Content-Length Header for a variable combined_file_sizes
920400
1
Limit file size
Limits the size of a file by checking Content-Length Header for a variable max_file_size
detects HTTP requests with a number of arguments exceeding the configurable "Max amount of arguments" value
920370
1
Limit argument value length
detects HTTP requests argument values exceeding the configurable "Max argument value length" parameter
920360
1
Limit length of argument names
detects HTTP requests argument name length exceeding the configurable "Max length of argument name" value
920350
3
Host Header Is IP Address
Detects if the host header is a numeric IP address as it could be indicative of automated client access
920341
1
Missing Content-Type Header in request body
Detects requests that have content but no Content-Type header
920340
1
Empty Content-Type Header with Request Body
Checks if the Content-Type header is present on a request that has a Content-Length Value
920330
1
Empty User-Agent Header
detects empty request user-agent header
920320
1
Missing User-Agent header
Detection of missing user-agent header
920310
920311
1
Empty Accept Header
Checks if an Accept header exists, but has an empty value. Also, detect an empty Accept header if there is no user agent.
920300
2
Missing Accept Header
Detection of missing accept header.
920290
1
Missing Host Header
This rule checks for the presence of a host header or an empty host header.
920280
1
Missing/Empty Host Header
Missing/Empty Host Header
920272
1
Low Range Printable Characters
Detects requests that contain printable characters in the low range
920271
1
Nonprinting characters in request
This rule checks for nonprinting characters in the request
920270
1
Restrict type of characters sent
This rule uses the @validateByteRange operator to restrict the request payloads.
920260
1
Disallow use of full-width unicode as decoding evasions may be possible.
This rule looks for full-width encoding by looking for %u followed by 2 'f' characters and then 2 hex characters. It is a vulnerability that affected IIS circa 2007.
920230
1
Detect multiple url encoding
Detection of multiple URL encodings.
920220
920240
1
Check URL encodings
There are two different chained rules. We need to separate them as we are inspecting two different variables - REQUEST_URI and REQUEST_BODY. For REQUEST_BODY, we only want to run the @validateUrlEncoding operator if the content-type is application/x-www-form-urlencoding.
920210
1
Check duplicate or conflicting headers.
This rule inspects the Connection header and looks for duplicates of the keep-alive and close options.
920200
920201
1
Range Header Validation
This rule inspects the Range request header to see if it starts with 0.
920190
2
Range Header Validation
This rule inspects the Range request header to see if it starts with 0.
920181
1
Transfer Encoding Validation
Detects if content-length and Transfer-Encoding headers are present which breaks RFC
920180
2
Content-Length Header Validation
Detects if content-length and Transfer-Encoding headers are provided with every POST request
920171
1
GET/HEAD Requests Validation
detects if GET/HEAD requests contain request body by checking for Transfer-Encoding header since it is not a common practice
920170
1
GET/HEAD Requests Validation
detects if GET/HEAD requests contain request body by checking for content-length header since it is not a common practice
920160
1
Content-Length Header Validation
Detects if content-length HTTP header is not numeric
920120
2
File Name Validation
Detects multipart/form-data file name evasion attempts
920100
3
Request Line Format Validation against the HTTP RFC
Uses rule negation against the regex for positive security. The regex specifies the proper construction of URI request lines such as: "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]. It also outlines proper construction for CONNECT, OPTIONS and GET requests.
9200024
2
Limit length of request header size
detects size of http request header length
9200024
1
Limit length of request header size
detects size of http request header length
9200014
2
Limit Number of Request Headers
detects if there are more headers then the desired amount
9200014
1
Limit Number of Request Headers
detects if there are more headers then the desired amount
913120
1
Check URL args and filenames for Vulnerability Scanners
This rule inspects the URL arguments/ filenames for vulnerability scanner identifiers.
913110
1
Check HTTP Headers for Vulnerability Scanners
This rule inspects HTTP headers for vulnerability scanner identifiers.
913102
1
Check User-Agent for Web Crawlers/Bots
This rule inspects the User-Agent header for Web Crawlers/ Bots identifiers.
913101
1
Check User-Agent for Generic/Scripting
This rule inspects the User-Agent header for generic/ scripting identifiers.
913100
1
Check User-Agent for Vulnerability Scanners
This rule inspects the User-Agent header for vulnerability scanner identifiers.
911100
1
Restrict HTTP Request Methods
allows only request methods specified by the configurable "Allowed http methods" parameter
This vulnerability allows an attacker to abuse the batch-requests plugin sending requests to bypass the IP restriction of Admin API
202223944
1
Apache ShenYu Authentication Bypass Vulnerability
This vulnerability allows users to access /plugin api without authentication.
202222965
1
Spring MVC or Spring WebFlux Application Remote Code Execution (RCE) Vulnerability
A Spring MVC or Spring WebFlux application running on JDK 9+ may be vulnerable to remote code execution (RCE) via data binding.
202222963
1
Spring Cloud Function Remote Code Execution (RCE) Vulnerability
This vulnerability allows malicious users to provide a specially crafted SpEL as a routing-expression that may result in remote code execution and access to local resources
202222947
1
Spring Cloud Gateway Spring Code Injection Vulnerability
This vulnerability allows remote attackers to make a maliciously crafted request that could allow arbitrary remote execution on the remote host where the Gateway Actuator endpoint is enabled
This vulnerability may allow an unauthenticated attacker with network access to the BIG-IP system through the management port and/or self IP addresses to execute arbitrary system commands
Affected versions of Atlassian Confluence Server allow remote attackers to view restricted resources via a Pre-Authorization Arbitrary File Read vulnerability. The affected versions are before version 7.4.10, and from version 7.5.0 before 7.12.3.
202125297
1
Nagios XI version xi-5.7.5 vulnerable to OS Command Injection Attacks
Nagios XI version xi-5.7.5 vulnerable to OS Command Injection Attacks
202125296
1
Nagios XI version xi-5.7.5 vulnerable to OS Command Injection Attacks
Nagios XI version xi-5.7.5 vulnerable to OS Command Injection Attacks
202125282
1
SaltStack Salt salt.wheel.pillar_roots.write method before 3002.5 vulnerable to directory traversal attack
SaltStack Salt salt.wheel.pillar_roots.write method before 3002.5 vulnerable to directory traversal attack