KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#typescript #ai-agents #developer-tools #cli #codex #claude-code #react #mcp #open-source #deepseek-harness #dsh-plugin #ai

go-ftw

★ 179 Open GitHub ↗

Web Application Firewall Testing Framework - Go version

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Go-FTW - Framework for Testing WAFs in Go!

[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
[![Go Report Card](https://goreportcard.com/badge/github.com/coreruleset/go-ftw)](https://goreportcard.com/report/github.com/coreruleset/go-ftw)
[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](http://godoc.org/github.com/coreruleset/go-ftw)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/coreruleset/go-ftw)](https://pkg.go.dev/github.com/coreruleset/go-ftw)
[![Release](https://img.shields.io/github/v/release/coreruleset/go-ftw.svg?style=flat-square)](https://github.com/coreruleset/go-ftw/releases/latest)
[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=coreruleset_go-ftw&metric=coverage)](https://sonarcloud.io/dashboard?id=coreruleset_go-ftw)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=coreruleset_go-ftw&metric=alert_status)](https://sonarcloud.io/dashboard?id=coreruleset_go-ftw)
[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/coreruleset/go-ftw/badge)](https://securityscorecards.dev/viewer/?uri=github.com/coreruleset/go-ftw)

Go-FTW is a replacement for [FTW](https://pypi.org/project/ftw/) which had reached its limits in terms of maintainability and performance.

Features of Go-FTW include:
  - fully customizable HTTP traffic
  - CI/CD friendly
  - fast
  - syntax checking of test files

## Install

### Homebrew (macOS and Linux)

`go-ftw` can be installed on macOS and Linux via [Homebrew](https://brew.sh) using the [CRS tap](https://github.com/coreruleset/homebrew-tap):

```shell
brew tap coreruleset/tap
brew install go-ftw
```

To upgrade to the latest version:

```shell
brew upgrade go-ftw
```

### Linux

Download the latest release archive for your architecture from the [releases page](https://github.com/coreruleset/go-ftw/releases), then extract and install the binary:

```shell
# Replace <version> and <arch> with the appropriate values (e.g. 1.0.0 and amd64)
curl -sSL https://github.com/coreruleset/go-ftw/releases/download/v<version>/ftw_<version>_linux_<arch>.tar.gz | tar -xzf - ftw
sudo mv ftw /usr/local/bin/
```

Alternatively, `.deb` and `.rpm` packages are available on the [releases page](https://github.com/coreruleset/go-ftw/releases):

```shell
# Debian/Ubuntu (.deb)
sudo dpkg -i ftw_<version>_linux_<arch>.deb

# RHEL/Fedora (.rpm)
sudo rpm -i ftw_<version>_linux_<arch>.rpm
```

### Install with Go

If you have Go installed and configured to run Go binaries from your shell you can also run

```bash
go install github.com/coreruleset/go-ftw/v2@latest
```

Make sure your Go bin directory (typically `~/go/bin`) is on your `PATH`.

## Example Usage

The go-ftw is designed to run Web Application Firewall (WAF) unit tests. The primary focus is the [OWASP ModSecurity Core Rule Set](https://github.com/coreruleset/coreruleset).

In order to run the tests, you need to prepare the following:

1. Active WAF
2. Log where the WAF writes the alert messages
3. go-ftw config file `.ftw.yaml` in the local folder or in your home folder (see [YAML Config file](https://github.com/coreruleset/go-ftw#yaml-config-file) for more information).
4. At least one unit test in (go)-ftw's yaml format.

### YAML Config file

With the configuration, you can set paths for your environment, enable and disable features and you can also use it to alter the test results.

The config file has six basic settings:

* `logfile` : path to WAF log with alert messages, relative or absolute
* `testoverride` : a list of things to override (see [Overriding tests](https://github.com/coreruleset/go-ftw#overriding-tests) below)
* `mode` : "default" or "cloud" (only change it if you need "cloud")
* `logmarkerheadername` : name of an HTTP header used for marking log messages, usually `X-CRS-TEST` (see [How log parsing works](https://github.com/coreruleset/go-ftw#how-log-parsing-works) below)
* `maxmarkerretries` : the maximum number of times the search for log markers will be repeated; each time an additional request is sent to the web server, eventually forcing the log to be flushed
* `maxmarkerloglines` the maximum number of lines to search for a marker before aborting

You can probably leave the last three alone, they are set to sane defaults.

__Example with absolute logfile__:

```yaml
logfile: /apache/logs/error.log
logmarkerheadername: X-CRS-TEST
testoverride:
mode: "default"
```

__Example with relative logfile__:

```yaml
logfile: ../logs/error.log
logmarkerheadername: X-CRS-TEST
testoverride:
mode: "default"
```

__Example with minimal definitions__:

The minimal requirement for go-ftw is to have a logfile when running in default mode:

```yaml
logfile: ../logs/error.log
```

By default, _go-ftw_ looks for a file in `$PWD` / local folder with the name `.ftw.yaml`. If this can not be found, it will look in the user's HOME folder. You can pass the `--config <config file name>` to point it to a different file.

### Test File Format

FTW tests are written in YAML format following a standardized schema. The complete schema documentation is maintained in the [ftw-tests-schema](https://github.com/coreruleset/ftw-tests-schema) repository.

#### Basic Test Structure

A test file contains:
- **meta**: Metadata about the test file (author, description, name, tags)
- **rule_id**: The rule ID being tested
- **tests**: An array of test cases

Each test case includes:
- **test_id**: (Optional) Sequence number of the test for the rule specified by `rule_id`. When not set, the ID will be inferred from the position.
- **test_title**: (Optional) Human-readable title used for inclusion/exclusion of test runs
- **desc**: (Optional) Description of what the test does
- **tags**: (Optional) Array of tags for filtering tests
- **stages**: Array of test stages (request/response pairs)

#### Test Stages

Each stage consists of:
- **input**: The HTTP request to send
- **output**: The expected response and log behavior

##### Input Fields

The input section supports these fields:

- **dest_addr**: Destination address (IP or hostname)
- **port**: Port number
- **protocol**: Protocol (http/https)
- **uri**: Request URI
- **follow_redirect**: If true, follows redirect from previous stage (ignores port, protocol, address, URI)
- **version**: HTTP version (e.g., "HTTP/1.1")
- **method**: HTTP method (GET, POST, etc.)
- **headers**: Map of HTTP headers
- **data**: Request body data as plain string
- **encoded_data**: Request body data as base64 encoded string (allows complex payloads with invisible characters)
- **encoded_request**: Base64 encoded full HTTP request (overrides all other settings)
- **save_cookie**: Save cookies from response for subsequent requests
- **autocomplete_headers**: Auto-add common headers (Connection, Content-Length, Content-Type). Defaults to true.
- **stop_magic**: (Deprecated) No longer used
- **raw_request**: (Deprecated) Use `encoded_request` instead

##### Output Fields

The output section supports these validation fields:

- **status**: Expected HTTP status code
- **response_contains**: String that should appear in response body
- **log_contains**: String that should appear in WAF logs
- **no_log_contains**: String that should NOT appear in WAF logs
- **log**: Object containing log validation fields:
  - **expect_ids**: Array of rule IDs expected to trigger
  - **no_expect_ids**: Array of rule IDs that should NOT trigger
  - **match_regex**: Regular expression expected to match log content
  - **no_match_regex**: Regular expression that should NOT match log content
- **expect_error**: Boolean, whether an error is expected (no response from WAF)
- **retry_once**: Retry the test once if it fails (useful for phase 5 race conditions)
- **isolated**: Boolean, test should trigger only the single rule specified in `expect_ids` (default: false)

#### Example Test

```yaml
---
meta:
  author: "OWASP CRS"
  description: "Test for SQL Injection Detection"
  name: "942100.yaml"
rule_id: 942100
tests:
  - test_id: 1
    desc: "SQL Injection via UNION SELECT"
    stages:
      - input:
          dest_addr: "localhost"
          port: 80
          headers:
            User-Agent: "ModSecurity CRS 3 Tests"
            Host: "localhost"
          uri: "/index.html?id=1' UNION SELECT NULL--"
          method: "GET"
        output:
          status: 403
          log:
            expect_ids: [942100]
  - test_id: 2
    desc: "Benign request should pass"
    stages:
      - input:
          dest_addr: "localhost"
          port: 80
          headers:
            User-Agent: "ModSecurity CRS 3 Tests"
            Host: "localhost"
          uri: "/index.html?id=123"
          method: "GET"
        output:
          status: 200
          log:
            no_expect_ids: [942100]
```

#### Using Templates

Go-FTW supports Go templates and [Sprig functions](https://masterminds.github.io/sprig/) in test data:

```yaml
# Generate repeated characters
data: 'foo=%3d{{ "+" | repeat 34 }}'

# Read from environment
data: 'username={{ env "USERNAME" }}'

# Use random data
data: 'token={{ randAlphaNum 32 }}'
```

For complete schema documentation including all available fields and options, see the [FTW Tests Schema Documentation](https://github.com/coreruleset/ftw-tests-schema).

### WAF Server

I normally perform my testing using the [Core Rule Set](https://github.com/coreruleset/coreruleset/).

You can start the containers from that repo using `docker compose`:

```bash
git clone https://github.com/coreruleset/coreruleset.git
cd coreruleset
docker compose -f tests/docker-compose.yml up -d modsec2-apache
```

### Logfile

Running in default mode implies you have access to a logfile for checking the WAF behavior against test results. For this example, assuming you are in the base directory of the coreruleset repository, these are the configurations for `apache` and `nginx`:

```yaml
---
logfile: 'tests/logs/modsec2-apache/error.log'
```

```yaml
---
logfile: 'tests/logs/modsec3-nginx/error.log'
```

## Running

This is the help for the `run` command:
```bash
go-ftw run --help
Run all tests below a certain subdirectory. The command will search all y[a]ml files recursively and pass it to the test engine.

Usage:
  go-ftw run [flags]

Flags:
      --connect-timeout duration               timeout for connecting to endpoints during test execution (default 3s)
  -d, --dir string                             recursively find yaml tests in this directory (default ".")
  -e, --exclude string                         exclude tests matching this Go regular expression (e.g. to exclude all tests beginning with "91", use "^91.*").
                                               If you want more permanent exclusion, check the 'exclude' option in the config file.
      --fail-fast                              Fail on first failed test
      --failure-waf-logs-dir string            directory path for failure-waf-logs-file; defaults to the same directory as the WAF log file; see (log-file); see store-failure-waf-logs and failure-waf-logs-file
      --failure-waf-logs-file string           file name for WAF log entries for failed tests; defaults to 'go-ftw-failure-waf-logs.log'; see store-failure-waf-logs and failure-waf-logs-dir (default "go-ftw-failure-waf-logs.log")
  -f, --file string                            output file path for ftw tests. Prints to standard output by default.
  -g, --glob string                            override the filename glob pattern for matching test files (default "*.y*ml")
  -h, --help                                   help for run
  -i, --include string                         include only tests matching this Go regular expression (e.g. to include only tests beginning with "91", use "^91.*").
                                               If you want more permanent inclusion, check the 'include' option in the config file.
  -T, --include-tags string                    include tests tagged with labels matching this Go regular expression (e.g. to include all tests being tagged with "cookie", use "^cookie$").
  -l, --log-file string                        path to log file to watch for WAF events
      --max-marker-log-lines uint              maximum number of lines to search for a marker before aborting (default 500)
      --max-marker-retries uint                maximum number of times the search for log markers will be repeated.
                                               Each time an additional request is sent to the web server, eventually forcing the log to be flushed (default 20)
  -o, --output string                          output type for ftw tests. "normal" is the default. (default "normal")
  -r, --rate-limit duration                    Limit the request rate to the server to 1 request per specified duration. 0 is the default, and disables rate limiting.
      --read-timeout duration                  timeout for receiving responses during test execution (default 10s)
      --report-triggered-rules                 Report triggered rules for each test
      --show-failures-only                     shows only the results of failed tests
      --skip-tls-verification                  Skips TLS certificate checks. Useful for testing domains with self-signed TLS ceritificates.
      --store-failure-waf-logs                 saves WAF log entries for failed tests to a dedicated file, configureable through failure-waf-logs-file and failure-waf-logs-dir
  -t, --time                                   show time spent per test
      --wait-delay duration                    Time to wait between retries for all wait operations. (default 1s)
      --wait-for-connection-timeout duration   Http connection timeout, The timeout includes connection time, any redirects, and reading the response body. (default 3s)
      --wait-for-expect-body-json string       Expect response body JSON pattern.
      --wait-for-expect-body-regex string      Expect response body pattern.
      --wait-for-expect-body-xpath string      Expect response body XPath pattern.
      --wait-for-expect-header string          Expect response header pattern.
      --wait-for-expect-status-code int        Expect response code e.g. 200, 204, ... .
      --wait-for-host string                   Wait for host to be available before running tests.
      --wait-for-no-redirect                   Do not follow HTTP 3xx redirects.
      --wait-for-timeout duration              Sets the timeout for all wait operations, 0 is unlimited. (default 10s)

Global Flags:
      --cloud              cloud mode: rely only on HTTP status codes for determining test success or failure (will not process any logs)
      --config string      specify config file (default is $PWD/.ftw.yaml)
      --debug              debug output
      --overrides string   specify file with platform specific overrides
      --trace              trace output: really, really verbose

```
All the wait for flags are implemented using the [wait4x](https://github.com/atkrad/wait4x#http) library.
See their examples on how to use them. In our flags we added the prefix `--wait-for` but they behave similarly.

Note: Duration flags above accept any input valid for [`time.ParseDuration`](https://pkg.go.dev/time#ParseDuration).

Here's an example on how to run your tests recursively in the folder `tests`:

```bash
ftw run -d tests -t
```

And the result should be similar to:

```bash
❯ ./ftw run -d tests -t

🛠️  Starting tests!
🚀 Running!
👉 executing tests in file 911100.yaml
	running 911100-1: ✔ passed 6.382692ms
	running 911100-2: ✔ passed 4.590739ms
	running 911100-3: ✔ passed 4.833236ms
	running 911100-4: ✔ passed 4.675082ms
	running 911100-5: ✔ passed 3.581742ms
	running 911100-6: ✔ passed 6.426949ms
...
	running 944300-322: ✔ passed 13.292549ms
	running 944300-323: ✔ passed 8.960695ms
	running 944300-324: ✔ passed 7.558008ms
	running 944300-325: ✔ passed 5.977716ms
	running 944300-326: ✔ passed 5.457394ms
	running 944300-327: ✔ passed 5.896309ms
	running 944300-328: ✔ passed 5.873305ms
	running 944300-329: ✔ passed 5.828122ms
➕ run 2354 total tests in 18.923445528s
⏭ skipped 7 tests
🎉 All tests successful!
```
Happy testing!

## Output

Now you can choose how the output of the test session is shown by passing the `-o` flag. The default output is `-o normal`,
and it will show the emojis in all the supported terminals. If yours doesn't support emojis, or you want a plain format,
you can use `-o plain`:
```shell
./ftw run -d tests -o plain -i 932240

** Running go-ftw!
	skipping 920360-1 - (enabled: false) in file.
	skipping 920370-1 - (enabled: false) in file.
	skipping 920380-1 - (enabled: false) in file.
	skipping 920390-1 - (enabled: false) in file.
=> executing tests in file 932240.yaml
	running 932240-1: + passed in 39.928201ms (RTT 67.096865ms)
	running 932240-2: + passed in 29.299056ms (RTT 65.650821ms)
	running 932240-3: + passed in 30.426324ms (RTT 63.173202ms)
	running 932240-4: + passed in 29.111381ms (RTT 66.593728ms)
	running 932240-5: + passed in 30.627351ms (RTT 67.101436ms)
	running 932240-6: + passed in 40.735442ms (RTT 79.628474ms)
+ run 6 total tests in 200.127755ms
>> skipped 3322 tests
\o/ All tests successful!
```

To support automation for processing the test results, there is also a new JSON output available using `-o json`:
```json
{
  "run": 8,
  "success": [
    "911100-1",
    "911100-2",
    "911100-3",
    "911100-4",
    "911100-5",
    "911100-6",
    "911100-7",
    "911100-8"
  ],
  "failed": null,
  "skipped": [
    "913100-1",
    "913100-2",
    "913100-3",
    "...",
    "980170-2"
  ],
  "ignored": null,
  "forced-pass": null,
  "forced-fail": null,
  "runtime": {
    "911100-1": 20631077,
    "911100-2": 14112617,
    "911100-3": 14524897,
    "911100-4": 14699391,
    "911100-5": 16137499,
    "911100-6": 16589660,
    "911100-7": 16741235,
    "911100-8": 20658905
  },
  "TotalTime": 134095281
}
```

Then it is easy to use your `jq` skils to get the information you want.

The list of supported outputs is:
- "normal"
- "quiet"
- "github"
- "json"
- "plain"
- "markdown"

`markdown` is primarily intended for `go-ftw quantitative`; on other commands it behaves like plain text output.
For `go-ftw quantitative` specifically, `-o github` is treated as an alias for `-o markdown`. For other commands,
`github` and `plain`/`markdown` remain distinct: `github` prints [workflow command](https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions) annotations instead of plain text.

#### Only show failures

If you are only interested to see when tests fail, there is a new flag `--show-failures-only` that does exactly that.
This is helpful when running in CI/CD systems like GHA to get shorter outputs.

## Additional features

- templates with the power of Go [text/template](https://golang.org/pkg/text/template/). Add your template to any `data:` sections and enjoy!
- [Sprig functions](https://masterminds.github.io/sprig/) can be added to templates as well.
- Override test results.
- Cloud mode! This new mode will ignore log files and rely solely on the HTTP status codes of the requests for determining success and failure of tests.

With templates and functions, you can simplify bulk test writing, or even read values from the environment while executing. These features allow you to write tests like this:

```yaml
data: 'foo=%3d{{ "+" | repeat 34 }}'
```

Will be expanded to:

```yaml
data: 'foo=%3d++++++++++++++++++++++++++++++++++'
```

But also, you can get values from the environment dynamically when the test is run:

```yaml
data: 'username={{ env "USERNAME" }}
```

Will give you, as you expect, the username running the tests:

```yaml
data: 'username=fzipi
```

Other interesting functions you can use are: `randBytes`, `htpasswd`, `encryptAES`, etc.

## Overriding tests

Sometimes you have tests that work well for some platform combinations, e.g. Apache + ModSecurity 2, but fail for others, e.g. NGiNX + ModSecurity 3. Taking that into account, you can override test results using the `testoverride` config param. The test will be skipped, and the result forced as configured.

Tests can be altered using four lists:
- `input` allows you to override global parameters in tests. The following ones can be overridden:
  - `dest_addr`: overrides the destination address (accepts IP or hostname)
  - `override_empty_host_header`: if true and `dest_addr` override is _also_ set, empty `Host` headers will be replaced with `dest_addr`
  - `port`: overrides the port number
  - `protocol`: overrides the protocol
  - `uri`: overrides the uri
  - `version`: overrides the HTTP version. E.g. "HTTP/1.1"
  - `ordered_headers`: overrides headers, the format is a list of `name` / `value` pairs
  - `method`: overrides the method used to perform the request
  - `data`: overrides data sent in the request
  - `autocomplete_headers`: overrides header autocompletion (currently sets `Connection: close` and `Content-Length` and `Content-Type` for requests with body data)
  - `encodedrequest`: overrides base64 encoded request
  - `virtual_host_mode`: set the `Host` header specified in tests for internal requests as well (overrides sending internal requests to `localhost`)
- `ignore` is for tests you want to ignore. You should add a comment on why you ignore the test
- `forcepass` is for tests you want to pass unconditionally. You should add a comment on why you force to pass the test
- `forcefail` is for tests you want to fail unconditionally. You should add a comment on why you force to fail the test

Each list is populated by regular expressions (see https://pkg.go.dev/regexp), which match against test IDs.
The following is an example using all the lists mentioned above:

```yaml
...
testoverride:
  input:
    dest_addr: "192.168.1.100"
    port: 8080
    protocol: "http"
  ignore:
    # text comes from our friends at https://github.com/digitalwave/ftwrunner
    '941190-3$': 'known MSC bug - PR #2023 (Cookie without value)'
    '941330-1$': 'know MSC bug - #2148 (double escape)'
    '942480-2$': 'known MSC bug - PR #2023 (Cookie without value)'
    '944100-11$': 'known MSC bug - PR #2045, ISSUE #2146'
    '^920': 'All the tests about Protocol Attack (rules starting with "920") will be ignored'
  forcefail:
    '123456-01$': 'I want this specific test to fail, even if passing'
  forcepass:
    '123456-02$': 'This test will always pass'
    '123457-.*': 'All the tests about rule 123457 will always pass'
```

You can combine any of `ignore`, `forcefail` and `forcepass` to make it work for you.

## ☁️ Cloud mode

Most of the tests rely on having access to a logfile to check for success or failure. Sometimes that is not possible, for example, when testing cloud services or servers where you don't have access to logfiles and/or logfiles won't have the information you need to decide if the test was good or bad.

With cloud mode, we move the decision on test failure or success to the HTTP status code received after performing the test. The general idea is that you set up your WAF in blocking mode, so anything matching will return a block status (e.g. 403), and if not we expect a 2XX return code.

You will also want to override the IP configured in the tests, and use the one from your cloud provider instead.

An example config file for this is:
```yaml
---
mode: 'cloud'
testoverride:
  input:
    dest_addr: "<your cloud WAF IP>"
    port: 80
```
Save this file as `cloud-test.yaml` and edit the WAF IP.

Then run: `./ftw run --config cloud-test.yaml`

## How log parsing works

The WAF's log file with the alert messages is parsed and compared to the expected output defined in the unit test under `log_contains` or `no_log_contains`.
Note that the expected output may contain multiple checks (E.g. `log_contains` and `status`). If any of the checks fail, the test will fail.

The problem with log files is that `go-ftw` is very, very fast and the log files are not updated in real time. Frequently, the
web server / WAF is not syncing the file fast enough. That results in a situation where `go-ftw` won't find the log messages it has triggered.

To make log parsing consistent and guarantee that we will see output when we need it, `go-ftw` will send a request that is meant to write a marker into the log file before the individual test and another marker after the individual test.

If `go-ftw` does not see the finishing marker after executing the request, it will send the marker request again until the webserver is forced to write the log file to the disk and the marker can be found.

The [container images for Core Rule Set](https://github.com/coreruleset/modsecurity-crs-docker) can be configured to write these marker log lines by setting
the `CRS_ENABLE_TEST_MARKER` environment variable. If you are testing a different test setup, you will need to instrument it with a rule that generated the marker in the log file via a rule alert (unless you are using "cloud mode").

The rule for CRS looks like this:

```
# Write the value from the X-CRS-Test header as a marker to the log
SecRule REQUEST_HEADERS:X-CRS-Test "@rx ^.*$" \
  "id:999999,\
  pass,\
  phase:1,\
  log,\
  msg:'X-CRS-Test %{MATCHED_VAR}',\
  ctl:ruleRemoveById=1-999999"
```

The rule looks for an HTTP header named `X-CRS-Test` and writes its value to the log, the value being the UUID of a test stage. If the header does not exist, the rule will be skipped and no marker will be written. If the header is found, the rule will also disable all further matching against the request to ensure that reported matches only concern actual test requests.

You can configure the name of the HTTP header by setting the `logmarkerheadername` option in the configuration to a custom value (the value is case-insensitive).

## Wait for backend service to be ready

Sometimes you need to wait for a backend service to be ready before running the tests. For example, you may need to wait for an additional container to be ready before running the tests.
Now you can do that by passing the `--wait-for-host` flag. The value of this option is a URL that will be requested, and you can configure the expected result using the following additional flags:
- `--wait-for-host`:                     Wait for host to be available before running tests.
- `--wait-for-connection-timeout`        Http connection timeout, The timeout includes connection time, any redirects, and reading the response body. (default 3s)
- `--wait-for-expect-body-json`          Expect response body JSON pattern.
- `--wait-for-expect-body-regex`         Expect response body pattern.
- `--wait-for-expect-body-xpath`         Expect response body XPath pattern.
- `--wait-for-expect-header`             Expect response header pattern.
- `--wait-for-expect-status-code`        Expect response code e.g. 200, 204, ... .
- `--wait-delay`:                        Time to wait between retries for all wait operations. (default 1s)
- `--wait-for-insecure-skip-tls-verify`  Skips tls certificate checks for the HTTPS request.
- `--wait-for-no-redirect`               Do not follow HTTP 3xx redirects.
- `--wait-for-timeout`                   Sets the timeout for all wait operations, 0 is unlimited. (default 10s)

## Quantitative testing

### What is the idea behind quantitative tests?

Quantitative testing mode provides a means to to quantify the amount of false positives to be expected in production for a given rule.
We use well-known corpora of texts to generate plausible, non-malicious payloads. Whenever such a payload is blocked by the WAF, the detection is considered to be a false positive.

Anyone can create their own corpora of texts and use them to test their WAF. Each corpus essentially consists of a list of strings, which may be sent to the WAF, depending on the configuration of the run.

The result of a test run is a percentage of false positives. The lower the percentage, the better the WAF is at not blocking benign payloads for a given rule. However, since we use generic corpora in our tests, the strings in those corpora will not necessarily be representative of the domain of a specific site. This means that a rule with a low false positive rate can still produce many false positives in specific contexts, e.g., when a website contains programming language code.

### What is a corpus? Why do I need one?

A corpus is a collection of texts that is used to generate payloads.
The texts can contain anything, from news articles to books. The idea is to have a large collection of texts that can be used to generate payloads. Well-known corpora usually have a domain or context, e.g., news headlines, or English books of the 18th century.

The default corpus is the [Leipzig Corpora Collection](https://wortschatz.uni-leipzig.de/en/download/), which is a collection of texts from the web.

### How to create a corpus?

You can create your own corpus by collecting texts from the web, or from books, articles, etc.
You could even use the contents of your own website as a corpus! What you will need to do is to implement the following interfaces:
- `corpus.Corpus`
- `corpus.File`
- `corpus.Iterator`
- `corpus.Payload`

You can see an example of how to implement the `corpus.Corpus` interface in the `corpus/leipzig` package.

### How to run quantitative tests?

To run quantitative tests, you just need to pass the `quantitative` flag to `ftw`.

The corpus will be downloaded and cached locally for future use. You can also specify the size of the corpus,
the language, the source, and the year of the corpus. The bare minimum parameter that you must specify is the
directory where the CRS rules are stored.

Here is the help for the `quantitative` command:

```bash
❯ ./go-ftw quantitative -h
Run all quantitative tests

Usage:
  ftw quantitative [flags]

Flags:
  -c, --corpus string              Corpus to use for the quantitative tests. (default "leipzig")
  -L, --corpus-lang string         Corpus language to use for the quantitative tests. (default "eng")
  -n, --corpus-line int            Number is the payload line from the corpus to exclusively send.
      --corpus-local-path string   Path to store the local corpora. Defaults to .ftw folder under user's home directory.
  -s, --corpus-size string         Corpus size to use for the quantitative tests. Most corpora will have sizes like "100K", "1M", etc. (default "100K")
  -S, --corpus-source string       Corpus source to use for the quantitative tests. Most corpus will have a source like "news", "web", "wikipedia", etc. (default "news")
  -y, --corpus-year string         Corpus year to use for the quantitative tests. Most corpus will have a year like "2023", "2022", etc. (default "2023")
      --baseline string            Path to a prior quantitative JSON result to compare against.
      --compare-crs string         Path to another CRS tree to run with the same parameters and compare against.
  -C, --crs-path string            Path to top folder of local CRS installation. (default ".")
  -f, --file string                Output file path for quantitative tests. Prints to standard output by default.
  -h, --help                       help for quantitative
      --ignore-rules ints          Comma-separated list of rule IDs to exclude from aggregate false-positive metrics, e.g. 920272,920273,942432.
      --ignore-rules-file string   Path to a file containing rule IDs to exclude from aggregate false-positive metrics (one rule ID per line).
  -l, --lines int                  Number of lines of input to process before stopping.
      --max-concurrency int        maximum number of goroutines. Defaults to 10, or 1 if log level is debug/trace. (default 10)
      --all-paranoia-levels        Evaluate all CRS paranoia levels in one run.
  -o, --output string              Output type for quantitative tests. Use "markdown" for PR-comment-ready Markdown ("github" is accepted as an alias). (default "normal")
  -P, --paranoia-level int         Paranoia level used to run the quantitative tests. (default 1)
      --paranoia-levels ints       Paranoia levels to evaluate in one run, e.g. 1,2,3,4.
  -p, --payload string             Payload is a string you want to test using quantitative tests. Will not use the corpus.
  -r, --rule int                   Rule ID of interest: only show false positives for specified rule ID. Defaults to paranoia level 4 unless -P is also set.

### Example of running quantitative tests

This will run with the default leipzig corpus and size of 10K payloads.
```bash
❯ ./go-ftw quantitative -C ../coreruleset -s 10K
Running quantitative tests
Run 10000 payloads in 18.482979709s
Total False positive ratio: 408/10000 = 0.0408
False positives per rule:
  Rule 920220: 198 false positives
  Rule 920221: 198 false positives
  Rule 932235: 4 false positives
  Rule 932270: 2 false positives
  Rule 932380: 2 false positives
  Rule 933160: 1 false positives
  Rule 942100: 1 false positives
```

To report cumulative totals for multiple paranoia levels in one invocation, use `--paranoia-levels` (or `--all-paranoia-levels`). For example:

```bash
❯ ./go-ftw quantitative -C ../coreruleset -s 10K --paranoia-levels 1,2,3,4
```

This will run with the default leipzig corpus and size of 10K payloads, but only for the rule 920350.
```bash
❯ ./go-ftw quantitative -C ../coreruleset -s 10K -r 932270
Running quantitative tests
Run 10000 payloads in 15.218343083s
Total False positive ratio: 2/10000 = 0.0002
False positives per rule:
  Rule 932270: 2 false positives
```

Some rules are intentionally aggressive and dominate aggregate metrics. Use `--ignore-rules` to exclude
known-noisy rule IDs from the aggregate false-positive ratio (they are still listed separately in the output).
A comma-separated list or a file (one rule ID per line) are both supported.
```bash
❯ ./go-ftw quantitative -C ../coreruleset -s 10K --ignore-rules 920272,920273,942432
Run 10000 payloads (0 skipped) in 18.5s
Total False positive ratio: 6/10000 = 0.0006 (16093 FPs from 3 ignored rules not counted)
False positives per paranoia level:
  PL1: 6 false positives. FP Ratio: 6/10000 = 0.0006
False positives per rule id:
  920100 (PL1): 6 false positives. FP Ratio: 6/10000 = 0.0006
False positives for ignored rules (not counted in aggregate):
  920272 (PL3): 3489 false positives. FP Ratio: 3489/10000 = 0.3489
  920273 (PL4): 10000 false positives. FP Ratio: 10000/10000 = 1.0000
  942432 (PL4): 2604 false positives. FP Ratio: 2604/10000 = 0.2604
```

If you add `--debug` to the command, you will see the payloads that cause false positives.
```bash
❯ ./go-ftw quantitative -C ../coreruleset -s 10K --debug
Running quantitative tests
12:32PM DBG Preparing download of corpus file from https://downloads.wortschatz-leipzig.de/corpora/eng_news_2023_10K.tar.gz
12:32PM DBG filename eng_news_2023_10K-sentences.txt already exists
12:32PM DBG Using paranoia level: 1

12:32PM DBG False positive with string: And finally: "I'd also say temp nurses make a lot.
12:32PM DBG **> rule 932290 => Matched Data: "I'd found within ARGS:payload: And finally: "I'd also say temp nurses make a lot.
12:32PM DBG False positive with string: But it was an experience Seguin said she "wouldn't trade for anything."
12:32PM DBG **> rule 932290 => Matched Data: "wouldn't found within ARGS:payload: But it was an experience Seguin said she "wouldn't trade for anything."
12:32PM DBG False positive with string: Consolidated Edison () last issued its earnings results on Thursday, November 3rd.
12:32PM DBG **> rule 932235 => Matched Data: () last  found within ARGS:payload: Consolidated Edison () last issued its earnings results on Thursday, November 3rd.
```

The default language for the corpus is English, but you can change it to German using the `-L` flag.
```bash
❯ ./go-ftw quantitative -C ../coreruleset -s 10K -L deu
Running quantitative tests
4:18PM INF Downloading corpus file from https://downloads.wortschatz-leipzig.de/corpora/deu_news_2023_10K.tar.gz
Moved /Users/fzipitria/.ftw/extracted/deu_news_2023_10K/deu_news_2023_10K-sentences.txt to /Users/fzipitria/.ftw/deu_news_2023_10K-sentences.txt
Run 10000 payloads in 25.169846084s
Total False positive ratio: 44/10000 = 0.0044
False positives per rule:
  Rule 920220: 19 false positives
  Rule 920221: 19 false positives
  Rule 932125: 1 false positives
  Rule 932290: 5 false positives
```

Results can be shown in JSON format also, to be processed by other tools.
```bash
❯ ./go-ftw quantitative -C ../coreruleset -s 10K -o json

{"corpusSize":10000,"count":10000,"falsePositiveSentences":209,"falsePositives":408,"falsePositivesPerParanoiaLevel":{"1":408},"falsePositivesPerRule":{"920220":198,"920221":198,"932235":4,"932270":2,"932380":2,"933160":1,"942100":1,"942230":1,"942360":1},"skipped":0,"totalTimeSeconds":15.0311}%
```

Or in Markdown format for use in pull request comments.
```bash
❯ ./go-ftw quantitative -C ../coreruleset -s 10K -o markdown
```

```markdown
## Quantitative test results

⚠️ Quantitative testing detected false positives.

| Metric | Value |
|--------|-------|
| Payloads run | 10000 |
| Skipped payloads | 0 |
| False positives | 408 |
| Duration | 15.031086083s |
| False positive ratio | 408/10000 = 0.0408 |

### False positives per rule

| Rule ID | PL | False positives | Ratio |
|---------|----|-----------------|-------|
| 920220 | 1 | 198 | 198/10000 = 0.0198 |
| 920221 | 1 | 198 | 198/10000 = 0.0198 |
| 932235 | 1 | 4 | 4/10000 = 0.0004 |
...
```

### Comparing runs against a baseline

A current run can be compared against a reference in a single invocation. There are two mutually
exclusive ways to provide the reference:

- `--baseline <file>`: a JSON result emitted by a prior `quantitative -o json` run.
- `--compare-crs <dir>`: another CRS tree that is run with the same parameters, then compared.

A rule is treated as a regression when its false positives increase relative to the baseline. The
command exits with status `1` when any regression is detected, so it can gate a CI/CD pipeline.

```bash
# Compare the current tree against a saved baseline
❯ ./go-ftw quantitative -C ../coreruleset -s 10K -o json > baseline.json
❯ ./go-ftw quantitative -C ../coreruleset -s 10K --baseline baseline.json
```

With the default `normal` output, the comparison prints the current and baseline summaries followed
by the diff:

```text
Current quantitative results:
Run 10000 payloads (0 skipped) in 15.0s
Total False positive ratio: 410/10000 = 0.0410
...

Baseline quantitative results:
Run 10000 payloads (0 skipped) in 15.0s
Total False positive ratio: 408/10000 = 0.0408
...

Comparison:
Total false positive delta: 2
Per-rule deltas:
  932270 (PL1): baseline=2 current=4 delta=+2
Newly firing rules:
  none
Stopped firing rules:
  none
Regressions detected
```

With `-o json` the comparison is emitted as a single object with three sections:

```json
{
  "baseline": { "count": 10000, "skipped": 0, "totalTimeSeconds": 15.0, "falsePositives": 408, "falsePositivesPerRule": { "932270": { "paranoiaLevel": 1, "falsePositives": 2 } }, "falsePositivesPerParanoiaLevel": { "1": 408 } },
  "current":  { "count": 10000, "skipped": 0, "totalTimeSeconds": 15.0, "falsePositives": 410, "falsePositivesPerRule": { "932270": { "paranoiaLevel": 1, "falsePositives": 4 } }, "falsePositivesPerParanoiaLevel": { "1": 410 } },
  "regressions": {
    "detected": true,
    "falsePositivesDelta": 2,
    "perRuleDeltas":      { "932270": { "baselineParanoiaLevel": 1, "currentParanoiaLevel": 1, "baselineFalsePositives": 2, "currentFalsePositives": 4, "delta": 2 } },
    "newlyFiringRules":   {},
    "stoppedFiringRules": {}
  }
}
```

Fields:

- `baseline` / `current`: the full stats for each run (same shape as a plain `-o json` result).
- `regressions.detected`: `true` when at least one rule's false positives increased.
- `regressions.falsePositivesDelta`: total false positives in `current` minus `baseline`.
- `regressions.perRuleDeltas`: every rule present in either run, with before/after paranoia levels, before/after counts, and the signed delta.
- `regressions.newlyFiringRules`: rules that fired in `current` but not in `baseline`.
- `regressions.stoppedFiringRules`: rules that fired in `baseline` but not in `current`.

### Future work for quantitative tests

This feature will enable us to compare between two different versions of CRS (or any two rules) and see, for example,
if any modification to the rule has caused more false positives.

Integrating it to the CI/CD pipeline will allow us to check every PR for false positives before merging.

## Library usage

`go-ftw` can be used as a library also. Just include it in your project:
```sh
go get github.com/coreruleset/go-ftw
```

Then, for the example below, import at least these:
```go
package main

import (
    "net/url"
    "os"
    "path/filepath"
    "strconv"

"github.com/bmatcuk/doublestar/v4"
    "github.com/coreruleset/go-ftw/config"
    "github.com/coreruleset/go-ftw/output"
    "github.com/coreruleset/go-ftw/runner"
    "github.com/coreruleset/go-ftw/test"
    "github.com/rs/zerolog"
)
```

And a sample code:
```go
     // sample from https://github.com/corazawaf/coraza/blob/v3/dev/testing/coreruleset/coreruleset_test.go#L215-L251
    var tests []test.FTWTest
    err = doublestar.GlobWalk(crsReader, "tests/regression/tests/**/*.yaml", func(path string, d os.DirEntry) error {
        yaml, err := fs.ReadFile(crsReader, path)
        if err != nil {
            return err
        }
        t, err := test.GetTestFromYaml(yaml)
        if err != nil {
            return err
        }
        tests = append(tests, t)
        return nil
    })
    if err != nil {
        log.Fatal(err)
    }

u, _ := url.Parse(s.URL)
    host := u.Hostname()
    port, _ := strconv.Atoi(u.Port())
    zerolog.SetGlobalLevel(zerolog.InfoLevel)
    cfg, err := config.NewConfigFromFile(".ftw.yml")
    if err != nil {
        log.Fatal(err)
    }
    cfg.LogFile = errorPath
    cfg.TestOverride.Input.DestAddr = &host
    cfg.TestOverride.Input.Port = &port
    runnerConfig := config.NewRunnerConfiguration(cfg)
    runnerConfig.ShowTime = false

res, err := runner.Run(runnerConfig, tests, output.NewOutput("quiet", os.Stdout))
    if err != nil {
        log.Fatal(err)
    }

if len(res.Stats.Failed) > 0 {
		log.Errorf("failed tests: %v", res.Stats.Failed)
	}
```

## License
[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fcoreruleset%2Fgo-ftw.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2Fcoreruleset%2Fgo-ftw?ref=badge_large)

go-ftw

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README