ModSecurity is available under two licenses. Users can choose to use the software under the terms of the GNU General Public License (http://www.gnu.org/licenses/gpl.html), as an Open Source / Free Software product. A range of commercial licenses is also available, together with a range of commercial support contracts. For more information on commercial licensing please contact Breach Security.

Unconditionally processes the action list it receives as the first and only parameter. It accepts one parameter, the syntax of which is identical to the third parameter of SecRule.

Specifies which character to use as separator for application/x-www-form-urlencoded content. Defaults to &. Applications are sometimes (very rarely) written to use a semicolon (;).

Configures the audit logging engine. Possible values are:

Path to the main audit logging file. This file will be used to store the audit log entries if serial audit logging format is used. If concurrent audit logging format is used this file will be used as an index, and contain a record of all audit log files created.

Default ABCFHZ.

Available audit log parts:

Configures which response status code is to be considered relevant for the purpose of audit logging. The parameter is a regular expression.

Configures the storage directory where concurrent audit log entries are to be stored. It must be writable by the web server user as new files are generated at runtime.

Possible values are:

Configures the directory path that will be used to jail the web server process.

Selects the cookie format that will be used in the current configuration context. Possible values are:

Path where persistent data (e.g. IP address data, session data, etc) is to be stored. Must be writable by the web server user.

Path to the debug log.

Possible values are:

Levels 1-3 are always sent to the Apache error log. Therefore you can always use level 0 as the default logging level in production. Level 5 is useful when debugging. It is not advisable to use higher logging levels in production as excessive logging can slow down server significantly.

Defines the default action to take on a rule match. The default value is:

SecDefaultAction log,auditlog,deny,status:403,phase:2,\
    t:lowercase,t:replaceNulls,t:compressWhitespace

Integration hook for httpd-guardian (see http://www.apachesecurity.net/tools/). For example:

SecGuardianLog |/path/to/httpd-guardian

Configures whether request bodies will be buffered and processed by ModSecurity by default. Possible values are:

Configures the maximum request body size ModSecurity will accept for buffering. Anything over this limit will be rejected with status code 413 Request Entity Too Large.

Configures the maximum request body size ModSecurity will store in memory. By default the limit is 128 KB:

# Store up to 128 KB in memory
SecRequestBodyInMemoryLimit 131072

Configures the maximum response body size that will be accepted for buffering. Anything over this limit will be rejected with status code 500 Internal Server Error. This setting will not affect the responses with MIME types that are not marked for buffering. By default this limit is configured to 512 KB:

# Buffer response bodies of up to 512 KB in length
SecResponseBodyLimit 524288

There is a hard limit of 1 GB.

Configures which MIME types are to be considered for response body buffering. The default value is text/plain text/html:

SecResponseBodyMimeType text/plain text/html

Multiple SecResponseBodyMimeType directives can be used to add MIME types.

Clears the list of MIME types considered for response body buffering, allowing you to start populating the list from scratch.

Configures whether response bodies are to be buffer and analysed or not. Possible values are:

SecRule is the main ModSecurity directive. It is used to analyse data and perform actions based on the results. In general, the format of this rule is as follows:

SecRule VARIABLES OPERATOR [ACTIONS]

The second part, OPERATOR, specifies how they are going to be checked. The third (optional) part, ACTIONS, specifies what to do whenever the operator used performs a successful match against a variable.

SecRule REQUEST_URI dirty

SecRule REQUEST_URI|QUERY_STRING dirty

SecRule ARGS dirty

SecRule ARGS:p dirty

SecRule ARGS|!ARGS:z dirty

SecRule &ARGS !^0$

SecRule ARGS:/^id_/ dirty

SecRule XML:/xPath/Expression dirty

SecRule REQUEST_URI "@rx dirty"

SecRule &ARGS "!@rx ^0$"

Configures whether the current context will inherit rules from the parent context (configuration options are inherited in most cases - you should look up the documentation for every directive to determine if it is inherited or not). Possible values are:

Configures whether or not the ModSecurity Rule Engine will process transactions or not. Possible values are:

Removes matching rules from the parent contexts. This directive supports multiple parameters, where each parameter can either be a rule ID, or a range. Parameters that contain spaces must be delimited using double quotes.

SecRuleRemoveById 1 2 5 10-20 "400 - 556" 673

Removes matching rules from the parent contexts. This directive supports multiple parameters. Each parameter is a regular expression that will be applied to the message (specified using the msg action).

Instructs ModSecurity to change web server signature.

SecServerSignature MyServer/1.0

Configures the directory where temporary files will be created.

Configures the directory where intercepted files will be stored. This directory must be on the same filesystem as the temporary directory defined with SecTmpDir.

Configures whether or not the intercepted files will be kept after transaction is processed. Possible values are:

This directive requires the storage directory to be defined (using SecUploadDir).

Creates a partition on the server that belongs to one web application. Partitions are used to avoid collisions between session IDs and user IDs. This directive must be used if there are multiple applications deployed on the same server. If it isn't a collision between session IDs might occur. The default value is default.

SecWebAppId "Intranet"

Rules in this phase immediately after Apache completes reading the request headers. At this point the request body has not been read yet, meaning not all request arguments are available. Rules should be placed in this phase if you need to have them run early (before Apache does something with the request), to do something before the request body has been read, determine whether or not the request body should be buffered, or decide how you want the request body to be processed (e.g. whether to parse it as XML or not).

This is the general-purpose input analysis phase. Most of the application-oriented rules should go here. In this phase you are guaranteed to have received the request argument (provided

This phase takes place just before response headers are sent back to the client. Run here if you want to observe the response before that happens, and if you want to use the response headers to determine if you want to buffer the response body.

This is the general-purpose output analysis phase. At this point you can run rules against the response body (provided it was buffered, of course).

This phase is run just before logging takes place. The rules placed into this phase can only affect how the logging is performed.

Stops processing on a successful match and allows transaction to proceed.

Marks the transaction for logging in the audit log.

When used together with the regular expression operator capture action will create copies of regular expression captures and place them into the transaction variable collection. Up to ten captures will be copied on a successful pattern match, each with a name consisting of a digit from 0 to 9.

Chains the rule where the action is placed with the rule that immediately follows it. The result is called a rule chain.

# Refuse to accept POST requests that do
# not specify request body length
SecRule REQUEST_METHOD ^POST$ chain
SecRule REQUEST_HEADER:Content-Length ^$

The ctl action allows configuration options to be updated for the transaction. The following configuration options are supported:

With the exception of requestBodyProcessor, each configuration option corresponds to one configuration directive and the usage is identical.

The requestBodyProcessor option allows you to configure the request body processor. By default ModSecurity will use the URLENCODED and MULTIPART processors to process an application/x-www-form-urlencoded and a multipart/form-data body, respectively. A third processor, XML, is also supported, but it is never used implicitly. Instead you must tell ModSecurity to use it by placing a few rules in the REQUEST_HEADERS processing phase.

# Parse requests with Content-Type "text/xml" as XML
SecRule REQUEST_CONTENT_TYPE ^text/xml nolog,pass,ctl:requestBodyProcessor=XML

After the request body was processed as XML you will be able to use the XML-related features to inspect it.

Stops rule processing and intercepts transaction.

Decrement counter based on its age. The following example will decrement the counter by 60 every 300 seconds.

deprecatevar:session.score=60/300

Counter values are always positive, meaning the value will never go below zero.

Note: causes error message to appear in the log "(9)Bad file descriptor: core_output_filter: writing data to the network"

Executes an external script/binary supplied as parameter.

Configures collection variable to expire after the given time in seconds.

expirevar:session.suspicious=3600

Assigns a unique ID to the rule or chain.

Initialises a named persistent collection, either by loading data from storage or by creating a new collection in memory. The following example initiates IP address tracking.

initcol:ip=%{REMOTE_ADDR}

Every collection contains several built-in variables that are read-only:

Collections are loaded into memory when the initcol action is encountered. The collection in storage will be updated (and the appropriate counters increased) only if it was changed during transaction processing.

Indicates that a successful match of the rule needs to be logged.

Assigns a custom message to the rule or chain.

If enabled ModSecurity will perform multiple operator invocations for every target, before and after every anti-evasion transformation is performed.

Indicates that a successful match of the rule should not be used as criteria whether the transaction should be logged to the audit log.

Prevents rule matches from appearing in the log.

Continues processing with the next rule in spite of a successful match. Transaction will not be interrupted but it will be logged (unless logging has been suppressed).

Pauses transaction processing for the specified number of milliseconds.

Places the rule (or the rule chain) into one of five available processing phases.

Intercepts transaction by forwarding request to another web server using the proxy backend.

Intercepts transaction by issuing a redirect to the given location. If the status action is present and its value is acceptable (301, 302, 303, or 307) it will be used for the redirection. Otherwise status code 302 will be used.

Specifies rule revision. This action is used in combination with the id action to allow the same rule ID to be used after changes take place but to still provide some indication the rule changed.

Sanitises (replaces each byte with an asterisk) a named request argument prior to audit logging.

sanitiseArg:password

Sanitises the variable (request argument, request header, or response header) that caused a rule match. This action can be used to sanitise arbitrary transaction elements when they match a condition. For example, the example below will sanitise any argument that contains the word password in the name.

SecRule ARGS_NAMES password nolog,pass,sanitiseMatched

Sanitises a named request header.

sanitiseRequestHeader:Authorization

Sanitises a names response header.

Assigns severity to the rule it is placed with.

Special-purpose action that initialises the USER collection. After initialisation takes place the variable USERID will be available for use in the subsequent rules.

Special-purpose action that initialises the SESSION collection. On first invocation of this action the collection will be empty (not taking the pre-defined variables into account - see initcol for more information). On subsequent invocations the contents of the collection (session, in this case) will be retrieved from storage. After initialisation takes place the variable SESSIONID will be available for use in the subsequent rules.

# Initialise session variables using the session cookie value
SecRule REQUEST_COOKIES:PHPSESSID !^$ chain,nolog,pass
SecAction setsid:%{REQUEST_COOKIES.PHPSESSID}

This action understands each application maintains its own set of sessions. It will utilise the current web application ID to create a session namespace.

Creates, removes, or updates an environment variable. This action can be used to establish communication with other Apache modules.

To create a new variable (if you omit the value 1 will be used):

setenv:name=value

To remove a variable:

setenv:!name

Creates, removes, or updates a variable in the specified collection.

To create a new variable:

setvar:tx.score=10

To remove a variable prefix the name with exclamation mark:

setvar:!tx.score

To increase or decrease variable value use + and - characters in front of a numerical value:

setvar:tx.score=+5

Skips one or more rules (or chains) on successful match. This action can not be used to skip rules within one chain.

Accepts a single paramater denoting the number of rules (or chains) to skip.

skip:3

Specifies the response status code to use with actions deny and redirect.

This action can be used which transformation function should be used against the specified variables before they (or the results, rather) are run against the operator specified in the rule.

This action should be used together with an XPath expression to register a namespace.

Numerical comparison.

Numerical comparison.

Numerical comparison.

Executes the external script/binary given as parameter to the operator against every file extracted from the request.

SecRule FILES_TMPNAMES "@inspectFile /opt/apache/bin/inspect_script.pl"

Numerical comparison.

Numerical comparison.

Look up the parameter in the RBL given as parameter. Parameter can be an IPv4 address, or a hostname.

SecRule REMOTE_ADDR "@rbl sc.surbl.org"

Regular expression operator. Regular expressions are handled by the PCRE library (http://www.pcre.org). ModSecurity compiles its regular expressions with the following settings:

Validates the byte range used in the variable falls into the specified range:

SecRule ARG:text "@validateByteRange 10, 13, 32-126"

SecRule XML "@validateDTD /path/to/file.dtd"

This operator requires request body to be processed as XML.

SecRule XML "@validateSchema /path/to/file.xsd"

This operator requires request body to be processed as XML.

Verifies the encodings used in the variable (if any) are valid.

Verifies the variable is a valid UTF-8 encoded string.