Rule files, and bans for a clear sign of attack (closes #24)

Every *.rules file in SWWAF_RULES_DIR is read at start and on each
change, and each request is checked against the rules after the rate
limits: log notes a match, block refuses with 403, ban refuses and bans
the netblock for SWWAF_ATTACK_BAN_DURATION, made permanent by its next
request or clear sign of attack. path, query and uri are matched as the
request line sent them. bans.json gains each ban's cause, and ban notes
count earlier bans by cause. The image ships 00-default.rules.

Judgement call: a header sent twice is matched with its values joined
by ", ".
Judgement call: SWWAF_MAX_BAN_DURATION does not cap a ban for an attack.
Not in this unit: offences for rule matches, with the error burst.

Model: opus-5-5

Dockerfile

@@ -167,6 +167,10 @@ RUN groupadd --system --gid 65532 smallwebwaf \
 # smallwebwaf user at each start.
 RUN mkdir /var/lib/smallwebwaf
 
+# The default rule file, in SWWAF_RULES_DIR by default, where an app's
+# Dockerfile can copy rule files of its own beside it.
+COPY share/rules.d/00-default.rules /etc/smallwebwaf/rules.d/00-default.rules
+
 # runsvinit starts runit's runsvdir on /etc/service, where Ubuntu's sv
 # looks too.
 COPY --chmod=755 share/smallwebwaf.run /etc/service/smallwebwaf/run

README.md

@@ -18,20 +18,21 @@ milestone 3: the static lists, the bans that broken rate limits lead to and the
 JSON state files with your edits taken in while it runs, which come next in the
 build order, `observe` mode, which comes a little later, and the metrics
 endpoint and the header size and the idle time as settings, which come last in
-it; and, from the stage after it, remote log sending. `smallwebwaf` passes each
-request to the app and the app's answer back, unchanged, within its timeouts and
-size limits, works out each client's address, bans a client that sends too many
-requests, refuses a client that comes from a country you refuse or from a
-network you refuse, lets the networks you choose through, keeps its bans, each
+it. So are the rule files, the first part of the stage after it, with the bans
+for a clear sign of attack. `smallwebwaf` passes each request to the app and the
+app's answer back, unchanged, within its timeouts and size limits, works out
+each client's address, bans a client that sends too many requests, refuses a
+client that comes from a country you refuse or from a network you refuse, lets
+the networks you choose through, checks each request against the rule files and
+bans a client whose request is a clear sign of attack, keeps its bans, each
 client's counters and history, and GeoJS's answers in JSON files across
-restarts, takes in your edits of those files while it runs, writes a JSON log
-line for every request, sends its log lines to a syslog server too if you name
-one, serves Prometheus metrics to a scraper that holds the metrics token, and in
-`observe` mode passes on the requests it would refuse, logging what it would
-have done with them. It comes as the image the app's own image is built on. The
-rest of the design comes after that, in the order of the build order in
-[`SPEC.md`](SPEC.md). The survey of existing tools that led to the design is in
-[`EVALUATION.md`](EVALUATION.md).
+restarts, takes in your edits of those files and of the rule files while it
+runs, writes a JSON log line for every request, serves Prometheus metrics to a
+scraper that holds the metrics token, and in `observe` mode passes on the
+requests it would refuse, logging what it would have done with them. It comes as
+the image the app's own image is built on. The rest of the design comes after
+that, in the order of the build order in [`SPEC.md`](SPEC.md). The survey of
+existing tools that led to the design is in [`EVALUATION.md`](EVALUATION.md).
 
 ## Getting started
 
@@ -54,7 +55,8 @@ works.
 To work on the code, `make build` builds the binary alone, with Go installed,
 and `make run` builds and runs it, listening on port 8080 in front of an app at
 `SWWAF_UPSTREAM_URL`, by default `http://127.0.0.1:8081`, with its state files
-in `bin/state` unless `SWWAF_STATE_DIR` is set.
+in `bin/state` unless `SWWAF_STATE_DIR` is set, and the default rule file of
+`share/rules.d` unless `SWWAF_RULES_DIR` is set.
 
 ## What it does so far
 
@@ -101,11 +103,26 @@ in `bin/state` unless `SWWAF_STATE_DIR` is set.
   window and the requests counted in it, the request that broke it, the client's
   country when it was looked up, the netblock's requests since it was first
   seen, how many of them the ban has refused, and how many bans the netblock had
-  before. At most `SWWAF_MAX_BANS` bans are kept, past, active and permanent;
-  past that, the earliest ban of the netblock that has gone longest without a
-  request is dropped first. `bans.json` shows the bans and their notes, a
-  restart lifts none, and you add or lift a ban by editing it (see "State files"
-  below).
+  before, for a broken limit, for a clear sign of attack and without a cause. At
+  most `SWWAF_MAX_BANS` bans are kept, past, active and permanent; past that,
+  the earliest ban of the netblock that has gone longest without a request is
+  dropped first. `bans.json` shows the bans and their notes, a restart lifts
+  none, and you add or lift a ban by editing it (see "State files" below).
+- Checks each request against the rules of the rule files (see "Rule files"
+  below) after the rate limits, and before its body is read. A `log` rule that
+  matches is noted in the log line; a `block` rule refuses the request with
+  `403`, and bans no one; a `ban` rule refuses it with `SWWAF_BAN_RESPONSE` and
+  bans the client's netblock for a clear sign of attack. Matching stops at the
+  first rule that refuses. A client in `SWWAF_ALLOW_NETS` is not checked.
+- Bans a client for a clear sign of attack, as "Bans" in [`SPEC.md`](SPEC.md)
+  describes: the first such ban lasts `SWWAF_ATTACK_BAN_DURATION`, seven days by
+  default, and any request from the netblock while it lasts makes it permanent.
+  Once it has run out, the netblock is served like any other, but its next clear
+  sign of attack bans it permanently at once. Such a ban covers the same
+  netblock as a ban for a broken rate limit, does not set the client's counters
+  back to zero, and does not make the netblock's next ban for a broken limit
+  longer. Its notes give the id and the target of the rule that matched in place
+  of the limit.
 - Refuses a request from a country you refuse with `SWWAF_BAN_RESPONSE`, as soon
   as the client's country is known and before its body is read; such a request
   is not counted for the rate limits. While one of the country lists below is
@@ -116,25 +133,26 @@ in `bin/state` unless `SWWAF_STATE_DIR` is set.
   in `SWWAF_ALLOW_NETS`, and `SWWAF_DENIED_COUNTRIES` does not refuse it.
 - Checks the client's own address against the static lists, the three netblock
   settings below, before anything else, its country included. A client in
-  `SWWAF_ALLOW_NETS` skips bans, the country lists and the rate limits, and is
-  not looked up; the timeouts and size limits still apply. A client in
-  `SWWAF_DENY_NETS` is refused with `SWWAF_BAN_RESPONSE` before its body is
-  read, and the request is not counted for the rate limits; an address in
-  `SWWAF_ALLOW_NETS` too is let through. A client in
+  `SWWAF_ALLOW_NETS` skips bans, the country lists, the rate limits and the rule
+  files, and is not looked up; the timeouts and size limits still apply. A
+  client in `SWWAF_DENY_NETS` is refused with `SWWAF_BAN_RESPONSE` before its
+  body is read, and the request is not counted for the rate limits; an address
+  in `SWWAF_ALLOW_NETS` too is let through. A client in
   `SWWAF_RATE_LIMIT_EXEMPT_NETS` is neither counted nor refused by the rate
-  limits; the country lists and bans still apply to it.
+  limits; the country lists, the rule files and bans still apply to it.
 - In `observe` mode, with `SWWAF_MODE=observe`, refuses none of the requests
-  that `SWWAF_DENY_NETS`, a ban, the country lists or a rate limit would refuse:
-  it passes them to the app, and their log lines name what `enforce` mode would
-  have done (see `would_action` in "Request log" below). The checks run, and
-  requests are counted, as in `enforce` mode, but a broken rate limit makes no
-  ban and does not set the client's counters back to zero, so each request over
-  the limit is logged as one that would be refused. The bans in `bans.json` are
-  kept, and refuse requests again when `smallwebwaf` next runs in `enforce`
-  mode, as long as they last. The timeouts and size limits still apply, since
-  they protect `smallwebwaf` and the app themselves, and a request for the
-  metrics without the token is still answered `401`. It is for trying a
-  configuration before enforcing it.
+  that `SWWAF_DENY_NETS`, a ban, the country lists, a rate limit or a rule would
+  refuse: it passes them to the app, and their log lines name what `enforce`
+  mode would have done (see `would_action` in "Request log" below). The checks
+  run, and requests are counted, as in `enforce` mode, with three differences:
+  neither a broken rate limit nor a `ban` rule makes a ban; a broken rate limit
+  does not set the client's counters back to zero, so each request over the
+  limit is logged as one that would be refused; and a request under a ban does
+  not make it permanent. The bans in `bans.json` are kept, and refuse requests
+  again when `smallwebwaf` next runs in `enforce` mode, as long as they last.
+  The timeouts and size limits still apply, since they protect `smallwebwaf` and
+  the app themselves, and a request for the metrics without the token is still
+  answered `401`. It is for trying a configuration before enforcing it.
 - Answers `GET /_smallwebwaf/healthz` itself with `200` and `ok`, before any
   check and without asking the app, for the image's health check.
 - Answers `GET /_smallwebwaf/metrics` with its metrics (see "Metrics" below) for
@@ -146,9 +164,6 @@ in `bin/state` unless `SWWAF_STATE_DIR` is set.
   passed to the app: a banned client stays refused, and each counts toward the
   client's rate limits. None of them reaches the app.
 - Writes a line in the request log for each request (see "Request log" below).
-- Sends every line it writes on stdout to a syslog server as well, while
-  `SWWAF_LOG_REMOTE_URL` names one (see "Sending the log to a syslog server"
-  below).
 
 ## Settings
 
@@ -187,8 +202,8 @@ it, and the effective settings are logged at start.
 - `SWWAF_REQUEST_MAX_BYTES` (default `100M`): the largest request body.
 - `SWWAF_RESPONSE_MAX_BYTES` (default `5G`): the largest response body.
 - `SWWAF_ALLOW_NETS` (default empty): netblocks whose clients skip bans, the
-  country lists and the rate limits, such as your monitoring or your own
-  networks.
+  country lists, the rate limits and the rule files, such as your monitoring or
+  your own networks.
 - `SWWAF_RATE_LIMIT_EXEMPT_NETS` (default empty): netblocks whose clients the
   rate limits do not apply to, such as a machine that talks to the app all day.
 - `SWWAF_DENY_NETS` (default empty): netblocks whose clients are always refused.
@@ -204,16 +219,20 @@ it, and the effective settings are logged at start.
   country cannot be found is refused too, so that new clients are not let in
   whenever GeoJS stops answering.
 - `SWWAF_BAN_RESPONSE` (default `403`): how a refused client is answered, one
-  that is banned, breaks a rate limit, is in `SWWAF_DENY_NETS` or comes from a
-  refused country: `403`, `429`, or `close` to close the connection without an
-  answer. Behind traefik, `close` does not leave the client unanswered: traefik
-  answers `502`, as it does whenever its backend drops a connection.
+  that is banned, breaks a rate limit, matches a `ban` rule, is in
+  `SWWAF_DENY_NETS` or comes from a refused country: `403`, `429`, or `close` to
+  close the connection without an answer. Behind traefik, `close` does not leave
+  the client unanswered: traefik answers `502`, as it does whenever its backend
+  drops a connection. A `block` rule always answers `403`.
 - `SWWAF_LIMIT_BAN_DURATION` (default `1h`): the ban for a first broken rate
   limit.
 - `SWWAF_LIMIT_BAN_REPEAT_WINDOW` (default `24h`): a rate limit broken again
-  within this time after a ban ended bans for three times as long as that ban.
-- `SWWAF_MAX_BAN_DURATION` (default `7d`): a ban that would be longer is
-  permanent instead.
+  within this time after a ban ended, other than one for a clear sign of attack,
+  bans for three times as long as that ban.
+- `SWWAF_MAX_BAN_DURATION` (default `7d`): a ban for a broken rate limit that
+  would be longer is permanent instead.
+- `SWWAF_ATTACK_BAN_DURATION` (default `7d`): the ban for a first clear sign of
+  attack.
 - `SWWAF_MAX_BANS` (default `5000`): the most bans kept, past, active and
   permanent.
 - `SWWAF_BAN_SCOPE_V4_PREFIX` (default `32`): the length of the netblock around
@@ -232,23 +251,10 @@ it, and the effective settings are logged at start.
   `********` in its place.
 - `SWWAF_METRICS_TOP_N` (default `50`): how many countries get series of their
   own in the metrics by country; the others are counted as `other`.
-- `SWWAF_LOG_REMOTE_URL` (default unset): a syslog server that every line on
-  stdout is also sent to, as `syslog+udp://`, `syslog+tcp://` or `syslog+tls://`
-  with a host and a port, such as `syslog+tls://logs.example:6514`. Unset or
-  empty, nothing is sent.
-- `SWWAF_LOG_REMOTE_TLS_CA_FILE` (default unset): a file of PEM certificates,
-  which the certificate of a `syslog+tls` server must chain to instead of the
-  host's own. A file that cannot be read or holds no certificate stops the
-  start.
-- `SWWAF_LOG_REMOTE_BUFFER` (default `10000`): the most lines held while they
-  wait to be sent.
-- `SWWAF_LOG_REMOTE_FACILITY` (default `local0`): the syslog facility the lines
-  are sent with: `kern`, `user`, `mail`, `daemon`, `auth`, `syslog`, `lpr`,
-  `news`, `uucp`, `cron`, `authpriv`, `ftp`, or `local0` to `local7`.
-- `SWWAF_LOG_REMOTE_APP_NAME` (default the host's name): the app name the lines
-  are sent with, 1 to 48 printable ASCII characters without a space. While
-  `SWWAF_LOG_REMOTE_URL` is set, a default that is not such a name stops the
-  start too.
+- `SWWAF_RULES_DIR` (default `/etc/smallwebwaf/rules.d`): the directory of the
+  rule files. A directory that does not exist stops the start.
+- `SWWAF_RULES_ENABLED` (default `true`): `false` reads no rule file, and checks
+  no request against one.
 
 Durations are in Go's syntax, with `d` for days (`90s`, `15m`, `7d`). Sizes are
 bytes, with an optional `K`, `M` or `G`, which are powers of 1024 (`1K` is 1024
@@ -258,8 +264,8 @@ ISO 3166-1 assigns today, and `xk` for Kosovo, in either case (`de` and `DE` are
 the same); any other code, such as `nk` (North Korea is `kp`) or the withdrawn
 `su`, stops the start, and so does a code on both country lists. `off` switches
 a timeout, a size limit or a rate limit off;
-`SWWAF_CLIENT_REQUEST_HEADER_MAX_BYTES`, the ban settings, the state settings,
-`SWWAF_METRICS_TOP_N` and `SWWAF_LOG_REMOTE_BUFFER` cannot be off.
+`SWWAF_CLIENT_REQUEST_HEADER_MAX_BYTES`, the ban settings, the state settings
+and `SWWAF_METRICS_TOP_N` cannot be off.
 
 Several limits are fixed rather than settings. At most 20,000 clients are kept,
 with their counters and history, and an IPv6 client is counted by its /64. A new
@@ -287,18 +293,21 @@ refused ones included:
 - `request_bytes` and `response_bytes` count body bytes.
 - `action` is `forward` for a request passed to the app, `denied` for one
   refused because its client is in `SWWAF_DENY_NETS`, `banned` for one refused
-  because a ban covers its client, `country_denied` for one refused for its
-  client's country, `rate_limited` for one that broke a rate limit and banned
-  its client, `too_large` for a request or response over its size limit,
-  `timed_out` for one that ran out of time, `upstream_error` when the app could
-  not be reached or its answer broke off, and `admin` for one `smallwebwaf`
-  answered at its own endpoint.
+  because a ban covers its client or because it matched a `ban` rule, which bans
+  its client, `country_denied` for one refused for its client's country,
+  `rate_limited` for one that broke a rate limit and banned its client,
+  `rule_blocked` for one a `block` rule refused, `too_large` for a request or
+  response over its size limit, `timed_out` for one that ran out of time,
+  `upstream_error` when the app could not be reached or its answer broke off,
+  and `admin` for one `smallwebwaf` answered at its own endpoint.
 - `would_action` is there in `observe` mode for a request that
-  `SWWAF_DENY_NETS`, a ban, the country lists or a rate limit would have refused
-  in `enforce` mode, and names the action that refusal would have had: `denied`,
-  `banned`, `country_denied` or `rate_limited`. `action` then names what was
-  done: `forward` for a request passed to the app, and another action, such as
-  `too_large`, for one a size or time limit refused.
+  `SWWAF_DENY_NETS`, a ban, the country lists, a rate limit or a rule would have
+  refused in `enforce` mode, and names the action that refusal would have had:
+  `denied`, `banned`, `country_denied`, `rate_limited` or `rule_blocked`.
+  `action` then names what was done: `forward` for a request passed to the app,
+  and another action, such as `too_large`, for one a size or time limit refused.
+- `rule_ids` is there for a request that matched rules of the rule files, and
+  lists their ids in the order they matched, up to the one that refused it.
 - `limit_hit` is there for a request that broke a rate limit, and names the
   window whose limit it went over: `minute`, `hour` or `day`, the shortest if it
   went over several. `offence` is then `limit`.
@@ -319,30 +328,6 @@ which it answers `431`, headers slower than `SWWAF_CLIENT_REQUEST_TIMEOUT`,
 whose connection it closes without an answer, and requests it cannot read at
 all, which it answers itself, mostly with `400`.
 
-### Sending the log to a syslog server
-
-While `SWWAF_LOG_REMOTE_URL` is set, every line `smallwebwaf` writes on stdout,
-request lines and its own, is also sent to that syslog server, as the message of
-an RFC 5424 record: one record to a datagram over UDP, and over TCP and TLS each
-record after its length in bytes and a space. A record gives the facility
-`SWWAF_LOG_REMOTE_FACILITY` names, the severity informational, the time the line
-was written, in the same form as a request line's `time`, the host's name, and
-the app name `SWWAF_LOG_REMOTE_APP_NAME` gives. stdout is unchanged.
-
-The lines wait in a buffer of `SWWAF_LOG_REMOTE_BUFFER` lines and are sent from
-there, so a server that is slow or cannot be reached never holds up a request or
-stdout. When the buffer is full, its oldest line is dropped to make room. A line
-whose sending fails is dropped too, and the connection is made again at once. A
-failed attempt to connect is logged and followed by the next a second later,
-twice as long after each further failure up to a minute, and a second again once
-a connection is made. UDP gives no sign of what arrives, and over TCP and TLS a
-line sent on a connection the server has just closed can be lost before a
-failure shows; such a loss is not counted.
-
-As `smallwebwaf` stops, it sends the lines still waiting, on the connection open
-or a new one, for at most two seconds, and gives up the rest; stdout has carried
-them.
-
 ## State files
 
 `smallwebwaf` keeps its state in memory and a copy of it in three JSON files in
@@ -351,7 +336,8 @@ them.
 entries by client address, with times in UTC.
 
 - `bans.json`: every ban with its notes, indented to be read; a permanent ban's
-  `expires` is `null`.
+  `expires` is `null`, and a ban `smallwebwaf` made has the `cause` `limit` for
+  a broken rate limit or `attack` for a clear sign of attack.
 - `clients.json`: each client's two buckets in the minute, the hour and the day,
   and its history: when it was first and last seen, its country as last looked
   up and when, its requests, how many were forwarded and how many refused (one
@@ -362,12 +348,13 @@ entries by client address, with times in UTC.
 - `lookups.json`: GeoJS's answers, one to a line, with when GeoJS gave each and
   when it was last used.
 
-`bans.json` is written `SWWAF_STATE_WRITE_DELAY` after a ban is made, with every
-ban made in between, and every file every `SWWAF_STATE_COUNTER_INTERVAL` and
-when `smallwebwaf` stops. Each write goes to a temporary file in the same
-directory, which then replaces the file, so a crash leaves the old file or the
-new one, whole. A write that fails is logged, and tried again at the next write.
-A hard kill loses what changed since the last write.
+`bans.json` is written `SWWAF_STATE_WRITE_DELAY` after a ban is made or made
+permanent, with every such change in between, and every file every
+`SWWAF_STATE_COUNTER_INTERVAL` and when `smallwebwaf` stops. Each write goes to
+a temporary file in the same directory, which then replaces the file, so a crash
+leaves the old file or the new one, whole. A write that fails is logged, and
+tried again at the next write. A hard kill loses what changed since the last
+write.
 
 At start the files are read back: each client keeps its counts, so a restart
 gives it no fresh allowance, and each ban keeps refusing every client in its
@@ -382,7 +369,8 @@ without a field it needs, named with the entry's place in the file: a ban's
 `netblock`, `start` or `expires`, which is `null` for a permanent ban; a
 client's `client`, or the `start` of a window in which it has requests; an
 answer's `client`, `country`, which is `""` for a client GeoJS cannot place, or
-`answered`. The AS number and AS name come with their lookup.
+`answered`. So does a ban whose `cause` is neither `limit` nor `attack`. The AS
+number and AS name come with their lookup.
 
 While it runs, `smallwebwaf` watches `SWWAF_STATE_DIR` and takes in your edit of
 a state file as soon as you save it: what the file then holds replaces what
@@ -391,17 +379,19 @@ yours by comparing the file with what it last read or wrote, and before it
 writes a file it takes in any edit made since, so your edit is not overwritten;
 a change `smallwebwaf` made after you opened the file, such as a new ban, is
 lost when you save over it. An edit that would stop the start, because it does
-not parse, has another `version` or leaves out a field an entry needs, does not
-stop the running `smallwebwaf`: it keeps what it holds, and at the file's next
-write renames your file to `<name>.bad`, such as `bans.json.bad`, writes the
-file again from memory, and logs the file and where the error is. It waits for
-that write because an editor's file can be read before the editor has finished
-writing it. Mend the `.bad` file and move it back. A file you remove is written
-again at its next write.
+not parse, has another `version`, leaves out a field an entry needs or gives a
+ban another `cause`, does not stop the running `smallwebwaf`: it keeps what it
+holds, and at the file's next write renames your file to `<name>.bad`, such as
+`bans.json.bad`, writes the file again from memory, and logs the file and where
+the error is. It waits for that write because an editor's file can be read
+before the editor has finished writing it. Mend the `.bad` file and move it
+back. A file you remove is written again at its next write.
 
 To ban a netblock, add an entry to `bans.json` with its `netblock`, its `start`
-and its `expires`, `null` for a ban that never ends; its `notes` may be left
-out. This `bans.json` bans `203.0.113.0/24` for good:
+and its `expires`, `null` for a ban that never ends; its `cause` and its `notes`
+may be left out. A ban whose `cause` is `attack` becomes permanent at the first
+request it refuses; one without a cause does not. This `bans.json` bans
+`203.0.113.0/24` for good:
 
 ```json
 {
@@ -419,6 +409,69 @@ out. This `bans.json` bans `203.0.113.0/24` for good:
 To lift a ban, delete its entry. `smallwebwaf` then forgets the ban, so it does
 not make the netblock's next ban longer.
 
+## Rule files
+
+`smallwebwaf` reads every `*.rules` file in `SWWAF_RULES_DIR`,
+`/etc/smallwebwaf/rules.d` by default, in the order of their names, and checks
+each request against their rules in that order, as "Rule files" in
+[`SPEC.md`](SPEC.md) describes. A rule is a line of four fields separated by
+spaces or tabs: an id, a target, an action and a regex, which runs to the end of
+the line. Blank lines and lines that start with `#` are ignored.
+
+```
+# id           target      action  regex
+env-file       path        ban     (?i)^/\.env(\.[a-z]+)?$
+scanner-agent  user_agent  ban     (?i)\b(sqlmap|nikto|nuclei|wpscan)\b
+```
+
+- The id is letters, digits, `-` and `_`, and no two rules share one. The
+  request log, the metrics and a ban's notes name the rule by it.
+- The target is what the regex is matched against: `path` or `query`, as the
+  client sent it, before any decoding; `uri`, the path and the query together,
+  both as sent and once percent-decoded, so that an encoded probe does not slip
+  past; `method`; `host`; `user_agent`; `referer`; or `header:<Name>`, any one
+  request header. A header sent more than once is matched with its values joined
+  by `, `, and one not sent as empty text. No body is read.
+- The action is `log`, `block` or `ban` (see "What it does so far" above). Keep
+  `ban` for requests no real visitor sends, and anchor a path at the site root
+  with `^/`: a file of the same name deeper in a site can be ordinary content,
+  such as a file in a repository on a code forge.
+- The regex is in Go's syntax, RE2, which has no backreferences or lookaround,
+  and takes time linear in the text it reads. It matches anywhere in the target
+  unless anchored with `^` and `$`; `(?i)` at its front makes it ignore case.
+
+A line that is not a rule, a regex that does not compile or an id used twice
+stops the start with a message naming the file and the line, and so does a
+`SWWAF_RULES_DIR` that does not exist. An empty directory is no error, and the
+log says that it holds no rules. While it runs, `smallwebwaf` watches the
+directory, and reads the rule files again whenever one is edited, added or
+removed. If they then hold one of those errors, the rules stay as they were, the
+earlier version of the edited file included, the log names the file and the
+line, and the files are read again at the next change.
+
+The image ships one rule file, `share/rules.d/00-default.rules` here: rules that
+ban probes no real visitor sends, for secrets, version control directories,
+backups, logs and web shells at the site root, and the user agents of common
+scanners; one that blocks `../` twice in a row in the path or the query; and one
+that only notes a request without a user agent. An app's Dockerfile adds rules
+of its own in a file beside it, named to sort after it, such as this
+`50-gitea.rules` for an app that serves no WordPress:
+
+```
+wp-probe  path  ban  (?i)^/(wp-login\.php|xmlrpc\.php|wp-admin/)
+```
+
+```dockerfile
+COPY 50-gitea.rules /etc/smallwebwaf/rules.d/50-gitea.rules
+```
+
+A directory mounted over `/etc/smallwebwaf/rules.d` replaces the default file,
+and single files mounted into it add to it. Docker does not show a single
+mounted file being replaced, which is how many editors save, so rules to be
+edited while `smallwebwaf` runs belong in a mounted directory, with a copy of
+`00-default.rules` if its rules are to stay. To run without rules, mount an
+empty directory or set `SWWAF_RULES_ENABLED=false`.
+
 ## Metrics
 
 `GET /_smallwebwaf/metrics` answers with the metrics in the Prometheus text
@@ -436,8 +489,11 @@ other request. No metric carries a client's address.
 - `smallwebwaf_rate_limit_hits_total` by `window`,
   `smallwebwaf_size_and_time_limit_hits_total` by `limit`, the setting whose
   limit was passed, `smallwebwaf_offences_total` by `kind`, and
-  `smallwebwaf_bans_made_total` by `cause`; `smallwebwaf_active_bans` and
-  `smallwebwaf_permanent_bans`.
+  `smallwebwaf_bans_made_total` by `cause`, `limit` or `attack`;
+  `smallwebwaf_active_bans` and `smallwebwaf_permanent_bans`.
+- `smallwebwaf_rule_matches_total`: the requests that matched each rule, by
+  `rule_id` and `action`, the rule's own; and `smallwebwaf_rules_loaded`: the
+  rules read from the rule files.
 - `smallwebwaf_country_requests_total`,
   `smallwebwaf_country_request_bytes_total`,
   `smallwebwaf_country_response_bytes_total`, and
@@ -460,16 +516,11 @@ other request. No metric carries a client's address.
   `smallwebwaf_state_file_edits_taken_in_total`: your edits taken in, and
   `smallwebwaf_state_file_edits_set_aside_total`: those renamed to `<name>.bad`
   because they would stop the start.
-- While `SWWAF_LOG_REMOTE_URL` is set,
-  `smallwebwaf_remote_log_lines_sent_total`: the lines sent to it;
-  `smallwebwaf_remote_log_lines_dropped_total`: those dropped, from a full
-  buffer or because their sending failed; and
-  `smallwebwaf_remote_log_buffer_depth`: those waiting in the buffer.
 - Go's own `go_` metrics and the process's `process_` metrics.
 
 The requests Go's HTTP server ends before `smallwebwaf` sees them (see "Request
 log") are not counted. The metrics of the features still to come, such as the
-rule files, come with them.
+Core Rule Set, come with them.
 
 ## Why
 
@@ -743,25 +794,29 @@ addresses are never sent to GeoJS.
 ## How the code is laid out
 
 - `cmd/smallwebwaf`: the binary, which only calls `internal/smallwebwaf`.
-- `internal/smallwebwaf`: the process: it reads the settings and the state
-  files, listens, serves requests until `SIGTERM` or `SIGINT`, and stops,
-  writing the state files. Run as `smallwebwaf healthcheck`, it is the image's
-  health check instead.
+- `internal/smallwebwaf`: the process: it reads the settings, the rule files and
+  the state files, listens, serves requests until `SIGTERM` or `SIGINT`, and
+  stops, writing the state files. Run as `smallwebwaf healthcheck`, it is the
+  image's health check instead.
 - `internal/config`: reads the settings, the one place they are read.
 - `internal/proxy`: what happens to each request: it works out the client, runs
   the checks, passes the request to the app and the answer back with the
   standard library's `httputil.ReverseProxy` within the timeouts and size
   limits, and writes the request's log line. Its `check` method is where a
   request is refused before anything reaches the app: for `SWWAF_DENY_NETS`, for
-  a ban, for the country lists, for a rate limit, which bans the client, and for
-  an announced body over the size limit; in `observe` mode, only for the size
-  limit, with what it would have refused for noted in the log line. A request
-  under `/_smallwebwaf/` that `check` lets through is answered by `answerAdmin`
+  a ban, for the country lists, for a rate limit, which bans the client, for a
+  `block` or `ban` rule, the latter banning the client, and for an announced
+  body over the size limit; in `observe` mode, only for the size limit, with
+  what it would have refused for noted in the log line. A request under
+  `/_smallwebwaf/` that `check` lets through is answered by `answerAdmin`
   instead of reaching the app.
 - `internal/metrics`: the metrics, counted as the other parts tell it what
   happened, and served in the Prometheus text format.
 - `internal/bans`: the ban ledger: each netblock's bans with their notes, how
-  long a new ban lasts, and which ban is dropped when `SWWAF_MAX_BANS` are held.
+  long a new ban lasts, when a ban for a clear sign of attack becomes permanent,
+  and which ban is dropped when `SWWAF_MAX_BANS` are held.
+- `internal/rules`: reads the rule files at start and again as they change, and
+  tells which of their rules a request matches.
 - `internal/lookup`: looks up each client's country through GeoJS, and keeps the
   answers.
 - `internal/ratelimit`: the table of clients: counts each client's requests,
@@ -770,13 +825,10 @@ addresses are never sent to GeoJS.
   one while running, and writes them when they are due and at the stop.
 - `internal/requestlog`: the lines on stdout: the request log line and the
   process's own messages.
-- `internal/remotelog`: sends the lines on stdout to `SWWAF_LOG_REMOTE_URL`,
-  each as a syslog record, from a buffer of its own. It is written with the
-  standard library alone, whose `log/syslog` writes only the older syslog
-  format.
 - `Dockerfile`: the lint and test phases, then the image, whose last stage
   installs Ubuntu's packages, nixpkgs, `runsvinit` and `smallwebwaf`, with
-  `share/smallwebwaf.run` as runit's `run` script for `smallwebwaf`.
+  `share/smallwebwaf.run` as runit's `run` script for `smallwebwaf` and
+  `share/rules.d/00-default.rules` as its default rule file.
 - `deploy/example-app`: an app built on the image, which `script/example-app`
   checks.
 
@@ -784,8 +836,8 @@ Besides the Go standard library, `github.com/hashicorp/golang-lru/v2` keeps the
 table of clients to 20,000, the GeoJS answers to 100,000 and the banned
 netblocks to `SWWAF_MAX_BANS`, dropping the least recently seen, and
 `github.com/prometheus/client_golang` keeps the metrics and serves them, and
-`github.com/fsnotify/fsnotify` tells `smallwebwaf` when a state file is saved.
-The country codes are the list in `internal/config/config.go`.
+`github.com/fsnotify/fsnotify` tells `smallwebwaf` when a state file or a rule
+file is saved. The country codes are the list in `internal/config/config.go`.
 
 ## Entrypoints
 
@@ -815,16 +867,17 @@ so that they run in minimal containers.
 - `script/build`: builds `bin/smallwebwaf` on the host, with Go installed, for
   working on the code by hand; `make build` runs it.
 - `script/run`: builds `bin/smallwebwaf` with `script/build` and runs it, with
-  its state files in `bin/state` unless `SWWAF_STATE_DIR` is set; `make run`
-  runs it.
+  its state files in `bin/state` unless `SWWAF_STATE_DIR` is set, and the rule
+  files of `share/rules.d` unless `SWWAF_RULES_DIR` is set; `make run` runs it.
 - `script/example-app`: builds the image and, on it, the example app in
   `deploy/example-app`, runs it with a volume for the state files, and checks
   that the health check passes, that a request reaches the app through
-  `smallwebwaf`, that a second request in a minute bans the client, that
-  `sv stop` and `docker stop` stop it in order, and that a new container on the
-  same volume still refuses the banned client; then removes the containers, the
-  volume and both images. It needs network access, for nixpkgs' binary cache,
-  and `script/check` does not run it; `make example-app` does.
+  `smallwebwaf`, that a second request in a minute bans the client, that a probe
+  for `/.env` bans another client, whose next request makes the ban permanent,
+  that `sv stop` and `docker stop` stop it in order, and that a new container on
+  the same volume still refuses the banned client; then removes the containers,
+  the volume and both images. It needs network access, for nixpkgs' binary
+  cache, and `script/check` does not run it; `make example-app` does.
 
 ## TODO
 

internal/bans/bans.go

@@ -1,7 +1,8 @@
 // Package bans is the ban ledger: the bans smallwebwaf makes on the
-// netblocks of clients that break a rate limit, with their notes, as the
-// "Bans" section of SPEC.md describes. The bans are kept in memory, and
-// written to bans.json and read from it by the state package.
+// netblocks of clients that break a rate limit or show a clear sign of
+// attack, with their notes, as the "Bans" section of SPEC.md describes.
+// The bans are kept in memory, and written to bans.json and read from it
+// by the state package.
 package bans
 
 import (
@@ -14,6 +15,15 @@ import (
 	"github.com/hashicorp/golang-lru/v2/simplelru"
 )
 
+// The causes of the bans smallwebwaf makes. A ban an admin adds to
+// bans.json may have no cause.
+const (
+	// CauseLimit is a ban for a broken limit.
+	CauseLimit = "limit"
+	// CauseAttack is a ban for a clear sign of attack.
+	CauseAttack = "attack"
+)
+
 // repeatFactor is how many times as long as the netblock's last ban a ban
 // for a limit broken again within the repeat window lasts.
 const repeatFactor = 3
@@ -21,32 +31,37 @@ const repeatFactor = 3
 // maxTextBytes is how much of each text in a ban's notes is kept.
 const maxTextBytes = 256
 
-// Rules are how long a ban for a broken limit lasts, and how many bans
-// are held.
+// Rules are how long a ban lasts, and how many bans are held.
 type Rules struct {
-	// LimitBanDuration is how long a first ban lasts.
+	// LimitBanDuration is how long a first ban for a broken limit lasts.
 	LimitBanDuration time.Duration
 	// LimitBanRepeatWindow is how soon after the end of the netblock's
-	// ban that ended last a broken limit counts as a repeat, which bans
-	// for repeatFactor times as long as that ban.
+	// ban that ended last, other than one for a clear sign of attack, a
+	// broken limit counts as a repeat, which bans for repeatFactor times as
+	// long as that ban.
 	LimitBanRepeatWindow time.Duration
-	// MaxBanDuration is the longest ban; a ban that would be longer is
-	// permanent instead.
+	// MaxBanDuration is the longest ban for a broken limit; one that would
+	// be longer is permanent instead.
 	MaxBanDuration time.Duration
+	// AttackBanDuration is how long a first ban for a clear sign of attack
+	// lasts.
+	AttackBanDuration time.Duration
 	// MaxBans is the most bans held, at least one. Past it, the earliest
 	// ban of the netblock that has gone longest without a request is
 	// dropped.
 	MaxBans int
 }
 
-// Ban is a ban on a netblock for a broken limit, the only kind of ban
-// smallwebwaf makes so far.
+// Ban is a ban on a netblock.
 type Ban struct {
 	Netblock netip.Prefix
 	Start    time.Time
 	// Expires is when the ban ends, zero for a permanent ban.
 	Expires time.Time
-	Notes   Notes
+	// Cause is CauseLimit or CauseAttack, or "" for a ban an admin added
+	// without one.
+	Cause string
+	Notes Notes
 }
 
 // Permanent reports whether the ban never runs out.
@@ -66,23 +81,39 @@ func (b Ban) ActiveAt(now time.Time) bool {
 type Notes struct {
 	// Country is the client's country, when it was looked up.
 	Country string `json:"country"`
-	// Limit, Window and Count are the limit that was broken, its window,
-	// "minute", "hour" or "day", and the count reached: the client's
-	// requests in the window, the one that broke the limit included.
-	// These are the requests that counted toward the ban, and the window
-	// is the time over which they came.
-	Limit  int64   `json:"limit"`
-	Window string  `json:"window"`
-	Count  float64 `json:"count"`
-	// Request is the request that broke the limit.
+	// Limit, Window and Count are, for a ban for a broken limit, the limit
+	// that was broken, its window, "minute", "hour" or "day", and the
+	// count reached: the client's requests in the window, the one that
+	// broke the limit included. These are the requests that counted
+	// toward the ban, and the window is the time over which they came.
+	Limit  int64   `json:"limit,omitempty"`
+	Window string  `json:"window,omitempty"`
+	Count  float64 `json:"count,omitempty"`
+	// RuleID and Target are, for a ban for a clear sign of attack, the id
+	// of the rule file rule that matched, and its target.
+	RuleID string `json:"rule_id,omitempty"`
+	Target string `json:"target,omitempty"`
+	// Request is the request that broke the limit, or that was the clear
+	// sign of attack.
 	Request Request `json:"request"`
 	// Requests is how many requests the netblock has sent since it was
 	// first seen, and Refused how many of them the ban has refused so
 	// far. Both go up with each request the ban refuses.
 	Requests int64 `json:"requests"`
 	Refused  int64 `json:"refused"`
-	// EarlierBans is how many bans the netblock had before this one.
-	EarlierBans int `json:"earlier_bans"`
+	// EarlierBans is how many bans the netblock had before this one, by
+	// cause.
+	EarlierBans EarlierBans `json:"earlier_bans"`
+}
+
+// EarlierBans counts a netblock's bans before a ban, by cause.
+//
+//nolint:tagliatelle // the state files use snake_case, as the request log does
+type EarlierBans struct {
+	Limit  int `json:"limit"`
+	Attack int `json:"attack"`
+	// WithoutCause counts the bans an admin added without a cause.
+	WithoutCause int `json:"without_cause"`
 }
 
 // Request is a request in a ban's notes. Each text is cut to 256 bytes.
@@ -112,8 +143,8 @@ type Ledger struct {
 	netblocks *simplelru.LRU[netip.Prefix, *[]Ban]
 	// held is how many bans netblocks holds, at most rules.MaxBans.
 	held int
-	// made is how many bans BanForLimit has made since the start.
-	made int
+	// made is how many bans the ledger has made since the start, by cause.
+	made map[string]int
 	// v4Lengths and v6Lengths are the lengths of the IPv4 and IPv6
 	// netblocks that have been banned. Check looks for a ban at each of
 	// them, so that a ban read from bans.json refuses every client in its
@@ -135,18 +166,21 @@ func New(rules Rules) *Ledger {
 		rules:     rules,
 		changed:   make(chan struct{}, 1),
 		netblocks: netblocks,
+		made:      map[string]int{},
 	}
 }
 
-// Changed receives a value after a ban is made, so that bans.json can be
-// written. Several bans made before it is read leave one value.
+// Changed receives a value after a ban is made or made permanent, so that
+// bans.json can be written. Several changes before it is read leave one
+// value.
 func (l *Ledger) Changed() <-chan struct{} {
 	return l.changed
 }
 
 // Check is called for a request from client, at now. It reports whether
 // a ban on a netblock client is in is active, and returns that ban, with
-// the request counted among those it refused.
+// the request counted among those it refused. A ban for a clear sign of
+// attack is made permanent by the request: the netblock is malicious.
 func (l *Ledger) Check(client netip.Addr, now time.Time) (Ban, bool) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
@@ -159,6 +193,12 @@ func (l *Ledger) Check(client netip.Addr, now time.Time) (Ban, bool) {
 	ban.Notes.Requests++
 	ban.Notes.Refused++
 
+	if ban.Cause == CauseAttack && !ban.Permanent() {
+		ban.Expires = time.Time{}
+
+		l.markChanged()
+	}
+
 	return *ban, true
 }
 
@@ -192,54 +232,22 @@ func activeBan(bans []Ban, now time.Time) *Ban {
 
 // BanForLimit bans netblock at now for a broken limit, with notes, and
 // returns the ban. A first ban lasts LimitBanDuration. A ban made within
-// LimitBanRepeatWindow after the netblock's ban that ended last lasts
-// repeatFactor times as long as that one. A ban that would be longer
-// than MaxBanDuration is permanent instead. If a ban on netblock is still
-// active, as when two of its requests break a limit at once, that ban is
-// returned and no other is made. The ledger fills in the notes' Refused
-// and EarlierBans itself.
+// LimitBanRepeatWindow after the netblock's ban that ended last, other
+// than one for a clear sign of attack, lasts repeatFactor times as long as
+// that one. A ban that would be longer than MaxBanDuration is permanent
+// instead. If a ban on netblock is still active, as when two of its
+// requests break a limit at once, that ban is returned and no other is
+// made. The ledger fills in the notes' Refused and EarlierBans itself.
 func (l *Ledger) BanForLimit(netblock netip.Prefix, now time.Time, notes Notes) Ban {
-	l.mu.Lock()
-	defer l.mu.Unlock()
+	return l.ban(netblock, now, CauseLimit, notes)
+}
 
-	var last *Ban
-
-	bans, found := l.netblocks.Get(netblock)
-	if found {
-		active := activeBan(*bans, now)
-		if active != nil {
-			return *active
-		}
-
-		// No ban is active, so each has an end. A ban an admin adds to
-		// bans.json can start after another and end before it, so the
-		// ban that ended last is looked for among them all.
-		ended := slices.MaxFunc(*bans, func(a, b Ban) int {
-			return a.Expires.Compare(b.Expires)
-		})
-		last = &ended
-
-		// The netblock's first ban held counts the bans it had before that
-		// one, since dropped to make room, and each ban held adds one.
-		notes.EarlierBans = (*bans)[0].Notes.EarlierBans + len(*bans)
-	}
-
-	notes.Request = notes.Request.cut()
-	ban := Ban{
-		Netblock: netblock,
-		Start:    now,
-		Expires:  l.expiry(last, now),
-		Notes:    notes,
-	}
-	l.add(ban)
-	l.made++
-
-	select {
-	case l.changed <- struct{}{}:
-	default: // a value is waiting already
-	}
-
-	return ban
+// BanForAttack bans netblock at now for a clear sign of attack, with
+// notes, and returns the ban, as BanForLimit does. A first ban lasts
+// AttackBanDuration; once the netblock has had one, the next is
+// permanent.
+func (l *Ledger) BanForAttack(netblock netip.Prefix, now time.Time, notes Notes) Ban {
+	return l.ban(netblock, now, CauseAttack, notes)
 }
 
 // Bans returns the bans held on netblock, oldest first. It is not a
@@ -256,13 +264,13 @@ func (l *Ledger) Bans(netblock netip.Prefix) []Ban {
 	return slices.Clone(*bans)
 }
 
-// Made returns how many bans the ledger has made since the start; bans
-// read from bans.json are not among them.
-func (l *Ledger) Made() int {
+// Made returns how many bans for cause the ledger has made since the
+// start; bans read from bans.json are not among them.
+func (l *Ledger) Made(cause string) int {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 
-	return l.made
+	return l.made[cause]
 }
 
 // Count returns how many of the bans held are active at now, and how many
@@ -332,6 +340,73 @@ func (l *Ledger) Load(bans []Ban) {
 	}
 }
 
+// ban bans netblock at now for cause, with notes, as BanForLimit and
+// BanForAttack describe, and returns the ban.
+func (l *Ledger) ban(
+	netblock netip.Prefix, now time.Time, cause string, notes Notes,
+) Ban {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	// held are the netblock's bans, none of them active.
+	var held []Ban
+
+	bans, found := l.netblocks.Get(netblock)
+	if found {
+		active := activeBan(*bans, now)
+		if active != nil {
+			return *active
+		}
+
+		held = *bans
+		notes.EarlierBans = earlierBans(held)
+	}
+
+	notes.Request = notes.Request.cut()
+	ban := Ban{Netblock: netblock, Start: now, Cause: cause, Notes: notes}
+
+	if cause == CauseAttack {
+		ban.Expires = l.attackExpiry(held, now)
+	} else {
+		ban.Expires = l.limitExpiry(held, now)
+	}
+
+	l.add(ban)
+	l.made[cause]++
+	l.markChanged()
+
+	return ban
+}
+
+// earlierBans returns how many bans a netblock with the bans held, oldest
+// first, has had, by cause: the first ban held counts the bans the
+// netblock had before that one, since dropped to make room, and each ban
+// held adds one.
+func earlierBans(held []Ban) EarlierBans {
+	earlier := held[0].Notes.EarlierBans
+
+	for _, ban := range held {
+		switch ban.Cause {
+		case CauseLimit:
+			earlier.Limit++
+		case CauseAttack:
+			earlier.Attack++
+		default:
+			earlier.WithoutCause++
+		}
+	}
+
+	return earlier
+}
+
+// markChanged has Changed receive a value, unless one is waiting already.
+func (l *Ledger) markChanged() {
+	select {
+	case l.changed <- struct{}{}:
+	default: // a value is waiting already
+	}
+}
+
 // active returns the ban active at now on a netblock client is in, or
 // nil.
 func (l *Ledger) active(client netip.Addr, now time.Time) *Ban {
@@ -383,12 +458,23 @@ func (l *Ledger) add(ban Ban) {
 	}
 }
 
-// expiry returns when a ban for a broken limit made at now ends, or zero
-// when it is permanent. last is the netblock's ban that ended last, or nil
-// when it has none.
-func (l *Ledger) expiry(last *Ban, now time.Time) time.Time {
+// limitExpiry returns when a ban for a broken limit made at now ends, or
+// zero when it is permanent. held are the netblock's bans, none of them
+// active, of which the one that ended last, other than a ban for a clear
+// sign of attack, can make the new ban longer. A ban an admin adds to
+// bans.json can start after another and end before it, so that one is
+// looked for among them all.
+func (l *Ledger) limitExpiry(held []Ban, now time.Time) time.Time {
 	length := l.rules.LimitBanDuration
 
+	var last *Ban
+
+	for i, ban := range held {
+		if ban.Cause != CauseAttack && (last == nil || ban.Expires.After(last.Expires)) {
+			last = &held[i]
+		}
+	}
+
 	if last != nil && now.Sub(last.Expires) <= l.rules.LimitBanRepeatWindow {
 		lastLength := last.Expires.Sub(last.Start)
 		// This is repeatFactor * lastLength > MaxBanDuration, written so
@@ -407,6 +493,20 @@ func (l *Ledger) expiry(last *Ban, now time.Time) time.Time {
 	return now.Add(length)
 }
 
+// attackExpiry returns when a ban for a clear sign of attack made at now
+// ends. held are the netblock's bans, none of them active: if one of them
+// is for a clear sign of attack too, the new ban is permanent, and its
+// end zero; otherwise it ends AttackBanDuration later.
+func (l *Ledger) attackExpiry(held []Ban, now time.Time) time.Time {
+	for _, ban := range held {
+		if ban.Cause == CauseAttack {
+			return time.Time{}
+		}
+	}
+
+	return now.Add(l.rules.AttackBanDuration)
+}
+
 // dropOne drops the earliest ban of the netblock that has gone longest
 // without a request, and the netblock with it if that was its only ban.
 func (l *Ledger) dropOne() {

internal/bans/bans_test.go

@@ -24,8 +24,9 @@ func TestRepeatsTripleUntilPermanent(t *testing.T) {
 		ban := ledger.BanForLimit(netblock, now, bans.Notes{})
 
 		length := time.Duration(hours) * time.Hour
-		if !ban.Expires.Equal(now.Add(length)) || ban.Notes.EarlierBans != i {
-			t.Fatalf("ban %d lasts %s with %d earlier bans, want %d hours and %d",
+		if !ban.Expires.Equal(now.Add(length)) ||
+			ban.Notes.EarlierBans != (bans.EarlierBans{Limit: i}) {
+			t.Fatalf("ban %d lasts %s with earlier bans %+v, want %d hours and %d for a limit",
 				i+1, ban.Expires.Sub(now), ban.Notes.EarlierBans, hours, i)
 		}
 
@@ -66,8 +67,9 @@ func TestRepeatWindowRunsOut(t *testing.T) {
 			first := ledger.BanForLimit(netblock, midnight(), bans.Notes{})
 			second := ledger.BanForLimit(netblock, first.Expires.Add(tc.gap), bans.Notes{})
 
-			if second.Expires.Sub(second.Start) != tc.want || second.Notes.EarlierBans != 1 {
-				t.Errorf("second ban lasts %s with %d earlier bans, want %s and 1",
+			if second.Expires.Sub(second.Start) != tc.want ||
+				second.Notes.EarlierBans != (bans.EarlierBans{Limit: 1}) {
+				t.Errorf("second ban lasts %s with earlier bans %+v, want %s and 1 for a limit",
 					second.Expires.Sub(second.Start), second.Notes.EarlierBans, tc.want)
 			}
 		})
@@ -235,9 +237,102 @@ func TestFullLedgerDropsTheEarlierBanOfTheNetblockBannedAgain(t *testing.T) {
 	second := ledger.BanForLimit(netblock, first.Expires, bans.Notes{})
 
 	held := ledger.Bans(netblock)
-	if len(held) != 1 || held[0] != second || held[0].Notes.EarlierBans != 1 {
-		t.Errorf("the ledger holds %+v, want only the second ban, with 1 earlier ban",
-			held)
+	if len(held) != 1 || held[0] != second ||
+		held[0].Notes.EarlierBans != (bans.EarlierBans{Limit: 1}) {
+		t.Errorf("the ledger holds %+v, want only the second ban, "+
+			"with 1 earlier ban for a limit", held)
+	}
+}
+
+func TestRequestDuringAnAttackBanMakesItPermanent(t *testing.T) {
+	t.Parallel()
+
+	ledger := bans.New(defaultRules())
+	netblock := netip.MustParsePrefix("203.0.113.9/32")
+	notes := bans.Notes{RuleID: "env-file", Target: "path"}
+
+	ban := ledger.BanForAttack(netblock, midnight(), notes)
+	if !ban.Expires.Equal(midnight().Add(7*day)) || ban.Cause != bans.CauseAttack ||
+		ban.Notes.RuleID != "env-file" || ledger.Made(bans.CauseAttack) != 1 ||
+		ledger.Made(bans.CauseLimit) != 0 {
+		t.Fatalf("the ban is %+v, with %d made for an attack and %d for a limit, "+
+			"want one for an attack, of seven days", ban,
+			ledger.Made(bans.CauseAttack), ledger.Made(bans.CauseLimit))
+	}
+
+	wantChanged(t, ledger, true)
+
+	// In observe mode the ban refuses nothing, and stays as it is.
+	got, _ := ledger.Find(netblock.Addr(), midnight().Add(time.Hour))
+	if got.Permanent() {
+		t.Fatal("a request found under the ban made it permanent")
+	}
+
+	// A request it refuses makes it permanent, and bans.json due.
+	got, _ = ledger.Check(netblock.Addr(), midnight().Add(time.Hour))
+	if !got.Permanent() || !ledger.Bans(netblock)[0].Permanent() {
+		t.Fatalf("after a request during the ban, it is %+v, want it permanent", got)
+	}
+
+	wantChanged(t, ledger, true)
+
+	_, banned := ledger.Check(netblock.Addr(), midnight().Add(100*365*day))
+	if !banned {
+		t.Error("the permanent ban ended")
+	}
+}
+
+func TestAttackAfterAnAttackBanHasEndedBansPermanently(t *testing.T) {
+	t.Parallel()
+
+	ledger := bans.New(defaultRules())
+	netblock := netip.MustParsePrefix("203.0.113.9/32")
+
+	// A ban for a broken limit before does not count.
+	first := ledger.BanForLimit(netblock, midnight(), bans.Notes{})
+	second := ledger.BanForAttack(netblock, first.Expires, bans.Notes{})
+
+	if second.Expires.Sub(second.Start) != 7*day {
+		t.Fatalf("the first ban for an attack lasts %s, want 7 days",
+			second.Expires.Sub(second.Start))
+	}
+
+	// Once that has run out without a request, the netblock is served, and
+	// its next clear sign of attack bans it for good.
+	_, banned := ledger.Check(netblock.Addr(), second.Expires)
+	if banned {
+		t.Fatal("the ban did not end")
+	}
+
+	// Its notes show the earlier ban for an attack that makes it permanent,
+	// beside the one for a limit.
+	third := ledger.BanForAttack(netblock, second.Expires.Add(30*day), bans.Notes{})
+	if !third.Permanent() ||
+		third.Notes.EarlierBans != (bans.EarlierBans{Limit: 1, Attack: 1}) {
+		t.Errorf("the next ban for an attack is %+v, want a permanent one, "+
+			"with 1 earlier ban for a limit and 1 for an attack", third)
+	}
+}
+
+func TestAttackBanDoesNotLengthenTheNextBanForALimit(t *testing.T) {
+	t.Parallel()
+
+	ledger := bans.New(defaultRules())
+	netblock := netip.MustParsePrefix("203.0.113.9/32")
+
+	// Three times the seven days would be permanent; a limit broken as the
+	// ban for an attack ends bans for an hour, as a first broken limit does.
+	attack := ledger.BanForAttack(netblock, midnight(), bans.Notes{})
+	limit := ledger.BanForLimit(netblock, attack.Expires, bans.Notes{})
+
+	if limit.Expires.Sub(limit.Start) != time.Hour || limit.Cause != bans.CauseLimit {
+		t.Errorf("the ban for a limit is %+v, want one of an hour", limit)
+	}
+
+	// And a request during the ban for a limit leaves it as it is.
+	got, _ := ledger.Check(netblock.Addr(), limit.Start)
+	if got.Permanent() {
+		t.Error("a request during a ban for a limit made it permanent")
 	}
 }
 
@@ -269,6 +364,7 @@ func defaultRules() bans.Rules {
 		LimitBanDuration:     time.Hour,
 		LimitBanRepeatWindow: day,
 		MaxBanDuration:       7 * day,
+		AttackBanDuration:    7 * day,
 		MaxBans:              5000,
 	}
 }

internal/bans/snapshot_test.go

@@ -82,8 +82,9 @@ func TestLoadedBansCarryOn(t *testing.T) {
 	}
 
 	again := after.BanForLimit(netblock, ban.Expires, bans.Notes{})
-	if again.Expires.Sub(again.Start) != 3*time.Hour || again.Notes.EarlierBans != 1 {
-		t.Errorf("the next ban lasts %s with %d earlier bans, want 3h and 1",
+	if again.Expires.Sub(again.Start) != 3*time.Hour ||
+		again.Notes.EarlierBans != (bans.EarlierBans{Limit: 1}) {
+		t.Errorf("the next ban lasts %s with earlier bans %+v, want 3h and 1 for a limit",
 			again.Expires.Sub(again.Start), again.Notes.EarlierBans)
 	}
 }
@@ -178,7 +179,8 @@ func TestNextBanWorkedOutFromTheBanThatEndedLast(t *testing.T) {
 		Netblock: netblock,
 		Start:    midnight(),
 		Expires:  midnight().Add(9 * time.Hour),
-		Notes:    bans.Notes{EarlierBans: 2},
+		Cause:    bans.CauseLimit,
+		Notes:    bans.Notes{EarlierBans: bans.EarlierBans{Limit: 2}},
 	}
 	admins := bans.Ban{
 		Netblock: netblock,
@@ -191,10 +193,13 @@ func TestNextBanWorkedOutFromTheBanThatEndedLast(t *testing.T) {
 
 	// Once both have ended, a limit broken within the repeat window bans
 	// for three times the 9 hours, and the notes count the two bans
-	// before the 9-hour one, it, and the admin's.
+	// before the 9-hour one and it, for a limit, and the admin's, without
+	// a cause.
 	ban := ledger.BanForLimit(netblock, nineHours.Expires.Add(time.Hour), bans.Notes{})
-	if ban.Expires.Sub(ban.Start) != 27*time.Hour || ban.Notes.EarlierBans != 4 {
-		t.Errorf("the next ban lasts %s with %d earlier bans, want 27h and 4",
+	if ban.Expires.Sub(ban.Start) != 27*time.Hour ||
+		ban.Notes.EarlierBans != (bans.EarlierBans{Limit: 3, WithoutCause: 1}) {
+		t.Errorf("the next ban lasts %s with earlier bans %+v, "+
+			"want 27h, 3 for a limit and 1 without a cause",
 			ban.Expires.Sub(ban.Start), ban.Notes.EarlierBans)
 	}
 }

internal/config/config.go

@@ -4,7 +4,6 @@
 package config
 
 import (
-	"crypto/x509"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -13,15 +12,12 @@ import (
 	"net/http"
 	"net/netip"
 	"net/url"
-	"os"
 	"path/filepath"
 	"slices"
 	"strconv"
 	"strings"
 	"time"
 	"unicode/utf8"
-
-	"sneak.berlin/go/smallwebwaf/internal/remotelog"
 )
 
 // Config is smallwebwaf's settings. A timeout, size or rate limit of zero
@@ -33,8 +29,8 @@ type Config struct {
 	UpstreamURL *url.URL
 	// Observe is true in observe mode, when SWWAF_MODE is observe rather
 	// than enforce: a request that SWWAF_DENY_NETS, a ban, the country
-	// lists or a rate limit would refuse is passed to the app instead, and
-	// no ban is made.
+	// lists, a rate limit or a rule would refuse is passed to the app
+	// instead, and no ban is made.
 	Observe bool
 	// TrustedProxies are the netblocks whose X-Forwarded-For is
 	// believed (SWWAF_TRUSTED_PROXIES).
@@ -89,7 +85,8 @@ type Config struct {
 	// BanResponse is the status a refused client is answered with, 403
 	// or 429, or 0 to close the connection without an answer
 	// (SWWAF_BAN_RESPONSE). It answers a banned client, a request that
-	// breaks a rate limit, SWWAF_DENY_NETS and the country lists.
+	// breaks a rate limit or matches a ban rule, SWWAF_DENY_NETS and the
+	// country lists.
 	BanResponse int
 	// LimitBanDuration is the ban for a first broken rate limit
 	// (SWWAF_LIMIT_BAN_DURATION). A limit broken again within
@@ -100,6 +97,9 @@ type Config struct {
 	LimitBanDuration     time.Duration
 	LimitBanRepeatWindow time.Duration
 	MaxBanDuration       time.Duration
+	// AttackBanDuration is the ban for a first clear sign of attack
+	// (SWWAF_ATTACK_BAN_DURATION). It cannot be off.
+	AttackBanDuration time.Duration
 	// MaxBans is the most bans held (SWWAF_MAX_BANS).
 	MaxBans int
 	// BanScopeV4Prefix is the length of the netblock around an IPv4
@@ -119,20 +119,10 @@ type Config struct {
 	// metrics (SWWAF_METRICS_TOP_N).
 	MetricsToken string
 	MetricsTopN  int
-	// LogRemoteURL is where every line on stdout is also sent
-	// (SWWAF_LOG_REMOTE_URL), nil while it is unset and nothing is sent.
-	// LogRemoteTLSCAs are the certificates a syslog+tls endpoint's
-	// certificate must chain to (SWWAF_LOG_REMOTE_TLS_CA_FILE), nil while
-	// it is unset and the host's own are used. LogRemoteBuffer is the most
-	// lines held while they wait to be sent (SWWAF_LOG_REMOTE_BUFFER).
-	// LogRemoteFacility is the number of the syslog facility
-	// (SWWAF_LOG_REMOTE_FACILITY), and LogRemoteAppName the APP-NAME
-	// (SWWAF_LOG_REMOTE_APP_NAME), of the records the lines are sent in.
-	LogRemoteURL      *url.URL
-	LogRemoteTLSCAs   *x509.CertPool
-	LogRemoteBuffer   int
-	LogRemoteFacility int
-	LogRemoteAppName  string
+	// RulesDir is the directory of the rule files (SWWAF_RULES_DIR), read
+	// unless RulesEnabled is false (SWWAF_RULES_ENABLED).
+	RulesDir     string
+	RulesEnabled bool
 
 	// settings are the values read, as given or by default, for the
 	// log line at start.
@@ -184,15 +174,9 @@ var (
 		"is not the length of an IPv4 netblock, from 0 to 32, such as 24")
 	errNotAbsolutePath = errors.New(
 		"is not an absolute path, such as /var/lib/smallwebwaf")
-	errShortToken      = errors.New("is shorter than 32 characters")
-	errNotMode         = errors.New("is not enforce or observe")
-	errNotLogRemoteURL = errors.New(
-		"is not syslog+udp, syslog+tcp or syslog+tls with a host and a port, " +
-			"and nothing more, such as syslog+tls://logs.example:6514")
-	errNoCertificate = errors.New("holds no PEM certificate")
-	errNotFacility   = errors.New("is not a syslog facility such as local0 or daemon")
-	errNotAppName    = errors.New(
-		"is not 1 to 48 printable ASCII characters without a space, such as gitea")
+	errShortToken = errors.New("is shorter than 32 characters")
+	errNotMode    = errors.New("is not enforce or observe")
+	errNotBoolean = errors.New("is not true or false")
 )
 
 // FromEnvironment reads the settings with lookupEnv, normally
@@ -227,6 +211,7 @@ func FromEnvironment(lookupEnv func(string) (string, bool)) (*Config, error) {
 		LimitBanDuration:     env.durationNotOff("SWWAF_LIMIT_BAN_DURATION", "1h"),
 		LimitBanRepeatWindow: env.durationNotOff("SWWAF_LIMIT_BAN_REPEAT_WINDOW", "24h"),
 		MaxBanDuration:       env.durationNotOff("SWWAF_MAX_BAN_DURATION", "7d"),
+		AttackBanDuration:    env.durationNotOff("SWWAF_ATTACK_BAN_DURATION", "7d"),
 		MaxBans:              env.numberNotOff("SWWAF_MAX_BANS", "5000"),
 		BanScopeV4Prefix:     env.v4Prefix("SWWAF_BAN_SCOPE_V4_PREFIX", "32"),
 		StateDir:             env.absolutePath("SWWAF_STATE_DIR", "/var/lib/smallwebwaf"),
@@ -234,16 +219,10 @@ func FromEnvironment(lookupEnv func(string) (string, bool)) (*Config, error) {
 		StateCounterInterval: env.durationNotOff("SWWAF_STATE_COUNTER_INTERVAL", "15m"),
 		MetricsToken:         env.token("SWWAF_METRICS_TOKEN"),
 		MetricsTopN:          env.numberNotOff("SWWAF_METRICS_TOP_N", "50"),
-		LogRemoteURL:         env.logRemoteURL("SWWAF_LOG_REMOTE_URL"),
-		LogRemoteTLSCAs:      env.certificates("SWWAF_LOG_REMOTE_TLS_CA_FILE"),
-		LogRemoteBuffer:      env.numberNotOff("SWWAF_LOG_REMOTE_BUFFER", "10000"),
-		LogRemoteFacility:    env.facility("SWWAF_LOG_REMOTE_FACILITY", "local0"),
+		RulesDir:             env.value("SWWAF_RULES_DIR", "/etc/smallwebwaf/rules.d"),
+		RulesEnabled:         env.boolean("SWWAF_RULES_ENABLED", "true"),
 	}
 
-	hostname, _ := os.Hostname() // "" when the host has no name to give
-	cfg.LogRemoteAppName = env.appName("SWWAF_LOG_REMOTE_APP_NAME", hostname,
-		cfg.LogRemoteURL != nil)
-
 	for _, country := range cfg.ExclusivelyAllowedCountries {
 		if slices.Contains(cfg.DeniedCountries, country) {
 			env.check("SWWAF_EXCLUSIVELY_ALLOWED_COUNTRIES",
@@ -325,6 +304,16 @@ func (e *environment) observe(name, defaultValue string) bool {
 	return mode == "observe"
 }
 
+// boolean reads a setting that is true or false.
+func (e *environment) boolean(name, defaultValue string) bool {
+	value := e.value(name, defaultValue)
+	if value != "true" && value != "false" {
+		e.check(name, fmt.Errorf("%q %w", value, errNotBoolean))
+	}
+
+	return value == "true"
+}
+
 // netblocks reads a setting that is a list of netblocks.
 func (e *environment) netblocks(name, defaultValue string) []netip.Prefix {
 	netblocks, err := parseNetblocks(e.value(name, defaultValue))
@@ -438,68 +427,6 @@ func (e *environment) token(name string) string {
 	return value
 }
 
-// logRemoteURL reads the setting that is where every log line is also
-// sent. Unset or empty, it is nil, and nothing is sent.
-func (e *environment) logRemoteURL(name string) *url.URL {
-	value := e.value(name, "")
-	if value == "" {
-		return nil
-	}
-
-	remote, err := parseLogRemoteURL(value)
-	e.check(name, err)
-
-	return remote
-}
-
-// certificates reads a setting that is the path of a file of PEM
-// certificates. Unset or empty, it is nil.
-func (e *environment) certificates(name string) *x509.CertPool {
-	path := e.value(name, "")
-	if path == "" {
-		return nil
-	}
-
-	pem, err := os.ReadFile(path) //nolint:gosec // a file the admin names
-	if err != nil {
-		e.check(name, fmt.Errorf("cannot be read: %w", err))
-
-		return nil
-	}
-
-	pool := x509.NewCertPool()
-	if !pool.AppendCertsFromPEM(pem) {
-		e.check(name, fmt.Errorf("%q %w", path, errNoCertificate))
-
-		return nil
-	}
-
-	return pool
-}
-
-// facility reads a setting that is a syslog facility, and returns its
-// number.
-func (e *environment) facility(name, defaultValue string) int {
-	number, err := parseFacility(e.value(name, defaultValue))
-	e.check(name, err)
-
-	return number
-}
-
-// appName reads the setting that is the APP-NAME of the records the log
-// lines are sent in. Its value is checked when it is set, and while lines
-// are sent, when they would be sent with its default.
-func (e *environment) appName(name, defaultValue string, sending bool) string {
-	_, set := e.lookupEnv(name)
-
-	value := e.value(name, defaultValue)
-	if (set || sending) && !isAppName(value) {
-		e.check(name, fmt.Errorf("%q %w", value, errNotAppName))
-	}
-
-	return value
-}
-
 // parseDuration reads a duration in Go's syntax, such as 90s or 15m, a
 // whole number of days such as 7d, or off.
 func parseDuration(value string) (time.Duration, error) {
@@ -804,64 +731,3 @@ func parseUpstreamURL(value string) (*url.URL, error) {
 
 	return upstream, nil
 }
-
-// parseLogRemoteURL reads where every log line is also sent:
-// syslog+udp, syslog+tcp or syslog+tls, a host and a port from 1 to
-// 65535, and nothing else.
-func parseLogRemoteURL(value string) (*url.URL, error) {
-	remote, err := url.Parse(value)
-	if err != nil {
-		return nil, fmt.Errorf("%q %w", value, errNotLogRemoteURL)
-	}
-
-	schemes := []string{remotelog.SchemeUDP, remotelog.SchemeTCP, remotelog.SchemeTLS}
-	port, err := strconv.ParseUint(remote.Port(), 10, 16)
-
-	onlySchemeHostAndPort := slices.Contains(schemes, remote.Scheme) &&
-		remote.Hostname() != "" && err == nil && port != 0 &&
-		remote.User == nil && remote.Opaque == "" &&
-		(remote.Path == "" || remote.Path == "/") &&
-		remote.RawQuery == "" && remote.Fragment == ""
-	if !onlySchemeHostAndPort {
-		return nil, fmt.Errorf("%q %w", value, errNotLogRemoteURL)
-	}
-
-	return remote, nil
-}
-
-// parseFacility reads the name of a syslog facility, and returns its
-// number, as RFC 5424 numbers them.
-func parseFacility(value string) (int, error) {
-	//nolint:mnd // the facilities' numbers in RFC 5424
-	number, known := map[string]int{
-		"kern": 0, "user": 1, "mail": 2, "daemon": 3, "auth": 4, "syslog": 5,
-		"lpr": 6, "news": 7, "uucp": 8, "cron": 9, "authpriv": 10, "ftp": 11,
-		"local0": 16, "local1": 17, "local2": 18, "local3": 19,
-		"local4": 20, "local5": 21, "local6": 22, "local7": 23,
-	}[value]
-	if !known {
-		return 0, fmt.Errorf("%q %w", value, errNotFacility)
-	}
-
-	return number, nil
-}
-
-// appNameMaxLength is the most characters RFC 5424 allows in an
-// APP-NAME.
-const appNameMaxLength = 48
-
-// isAppName reports whether value can be an APP-NAME: 1 to
-// appNameMaxLength printable ASCII characters, none of them a space.
-func isAppName(value string) bool {
-	if value == "" || len(value) > appNameMaxLength {
-		return false
-	}
-
-	for _, char := range []byte(value) {
-		if char < '!' || char > '~' {
-			return false
-		}
-	}
-
-	return true
-}

internal/config/config_test.go

@@ -2,13 +2,10 @@ package config_test
 
 import (
 	"bytes"
-	"crypto/x509"
 	"encoding/json"
 	"log/slog"
 	"maps"
 	"net/netip"
-	"os"
-	"path/filepath"
 	"slices"
 	"strings"
 	"testing"
@@ -43,6 +40,7 @@ const (
 	limitBanDuration        = "SWWAF_LIMIT_BAN_DURATION"
 	limitBanRepeatWindow    = "SWWAF_LIMIT_BAN_REPEAT_WINDOW"
 	maxBanDuration          = "SWWAF_MAX_BAN_DURATION"
+	attackBanDuration       = "SWWAF_ATTACK_BAN_DURATION"
 	maxBans                 = "SWWAF_MAX_BANS"
 	banScopeV4Prefix        = "SWWAF_BAN_SCOPE_V4_PREFIX"
 	stateDir                = "SWWAF_STATE_DIR"
@@ -50,27 +48,10 @@ const (
 	stateCounterInterval    = "SWWAF_STATE_COUNTER_INTERVAL"
 	metricsToken            = "SWWAF_METRICS_TOKEN" //nolint:gosec // the setting's name
 	metricsTopN             = "SWWAF_METRICS_TOP_N"
-	logRemoteURL            = "SWWAF_LOG_REMOTE_URL"
-	logRemoteTLSCAFile      = "SWWAF_LOG_REMOTE_TLS_CA_FILE"
-	logRemoteBuffer         = "SWWAF_LOG_REMOTE_BUFFER"
-	logRemoteFacility       = "SWWAF_LOG_REMOTE_FACILITY"
-	logRemoteAppName        = "SWWAF_LOG_REMOTE_APP_NAME"
+	rulesDir                = "SWWAF_RULES_DIR"
+	rulesEnabled            = "SWWAF_RULES_ENABLED"
 )
 
-// testCA is a CA certificate, of which only that it reads matters here.
-const testCA = `-----BEGIN CERTIFICATE-----
-MIIBkzCCATmgAwIBAgIUeySaE27dnr6A2HijrMB13gTLUKIwCgYIKoZIzj0EAwIw
-HjEcMBoGA1UEAwwTc21hbGx3ZWJ3YWYgdGVzdCBDQTAgFw0yNjEwMDYxNDI2MTNa
-GA8yMTI2MDkxMjE0MjYxM1owHjEcMBoGA1UEAwwTc21hbGx3ZWJ3YWYgdGVzdCBD
-QTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKDEhcWKKhet2KgSdME+iEPxyEyn
-2sd9IdElbt8DM2SfCdB2JsXo0C07UNZaywMPMfn/n8LNI/PKwu+N2uX7gfSjUzBR
-MB0GA1UdDgQWBBRZo3BPLv0KbV4drw6JI1JIUKmoRzAfBgNVHSMEGDAWgBRZo3BP
-Lv0KbV4drw6JI1JIUKmoRzAPBgNVHRMBAf8EBTADAQH/MAoGCCqGSM49BAMCA0gA
-MEUCICC5k+76UpWoSwVbZA+atu5WcALEOJGqwOUWua3zemhcAiEA8Hfdxgwp0z2v
-rlG9y/jrJb6ORy3kTLWo2EA0BA67vuI=
------END CERTIFICATE-----
-`
-
 // token is a token of 32 characters, the shortest allowed.
 const token = "0123456789abcdef0123456789abcdef"
 
@@ -122,6 +103,7 @@ func TestDefaults(t *testing.T) {
 		LimitBanDuration:            time.Hour,
 		LimitBanRepeatWindow:        24 * time.Hour,
 		MaxBanDuration:              7 * 24 * time.Hour,
+		AttackBanDuration:           7 * 24 * time.Hour,
 		MaxBans:                     5000,
 		BanScopeV4Prefix:            32,
 		StateDir:                    "/var/lib/smallwebwaf",
@@ -129,6 +111,8 @@ func TestDefaults(t *testing.T) {
 		StateCounterInterval:        15 * time.Minute,
 		MetricsToken:                "",
 		MetricsTopN:                 50,
+		RulesDir:                    "/etc/smallwebwaf/rules.d",
+		RulesEnabled:                true,
 	})
 
 	if cfg.UpstreamURL.String() != "http://127.0.0.1:8081" {
@@ -172,6 +156,7 @@ func TestValuesAsSet(t *testing.T) {
 		limitBanDuration:        "15m",
 		limitBanRepeatWindow:    "2d",
 		maxBanDuration:          "30d",
+		attackBanDuration:       "1d",
 		maxBans:                 "100",
 		banScopeV4Prefix:        "24",
 		stateDir:                "/srv/waf-state",
@@ -179,6 +164,8 @@ func TestValuesAsSet(t *testing.T) {
 		stateCounterInterval:    "1h",
 		metricsToken:            token,
 		metricsTopN:             "10",
+		rulesDir:                "/srv/waf-rules",
+		rulesEnabled:            "false",
 	})
 
 	wantSettings(t, cfg, config.Config{
@@ -199,6 +186,7 @@ func TestValuesAsSet(t *testing.T) {
 		LimitBanDuration:            15 * time.Minute,
 		LimitBanRepeatWindow:        48 * time.Hour,
 		MaxBanDuration:              30 * 24 * time.Hour,
+		AttackBanDuration:           24 * time.Hour,
 		MaxBans:                     100,
 		BanScopeV4Prefix:            24,
 		StateDir:                    "/srv/waf-state",
@@ -206,6 +194,8 @@ func TestValuesAsSet(t *testing.T) {
 		StateCounterInterval:        time.Hour,
 		MetricsToken:                token,
 		MetricsTopN:                 10,
+		RulesDir:                    "/srv/waf-rules",
+		RulesEnabled:                false,
 	})
 
 	if cfg.UpstreamURL.String() != "https://app.internal:8443/" {
@@ -220,131 +210,6 @@ func TestValuesAsSet(t *testing.T) {
 	wantCountries(t, allowedCountries, cfg.ExclusivelyAllowedCountries, "DE")
 }
 
-func TestRemoteLogSettingsDefaults(t *testing.T) {
-	t.Parallel()
-
-	cfg := fromEnvironment(t, environment{})
-	hostname, _ := os.Hostname()
-
-	if cfg.LogRemoteURL != nil || cfg.LogRemoteTLSCAs != nil ||
-		cfg.LogRemoteBuffer != 10000 || cfg.LogRemoteFacility != 16 ||
-		cfg.LogRemoteAppName != hostname {
-		t.Errorf("remote log settings %v, %v, %d, %d and %q, want no URL, no "+
-			"certificates, 10000, 16 and %q", cfg.LogRemoteURL, cfg.LogRemoteTLSCAs,
-			cfg.LogRemoteBuffer, cfg.LogRemoteFacility, cfg.LogRemoteAppName, hostname)
-	}
-}
-
-func TestRemoteLogSettingsAsSet(t *testing.T) {
-	t.Parallel()
-
-	caFile := filepath.Join(t.TempDir(), "ca.pem")
-
-	err := os.WriteFile(caFile, []byte(testCA), 0o600)
-	if err != nil {
-		t.Fatalf("write %s: %v", caFile, err)
-	}
-
-	cfg := fromEnvironment(t, environment{
-		logRemoteURL:       "syslog+tls://logs.example:6514",
-		logRemoteTLSCAFile: caFile,
-		logRemoteBuffer:    "500",
-		logRemoteFacility:  "daemon",
-		logRemoteAppName:   "fsn1app1/gitea",
-	})
-
-	roots := x509.NewCertPool()
-	roots.AppendCertsFromPEM([]byte(testCA))
-
-	if cfg.LogRemoteURL.String() != "syslog+tls://logs.example:6514" ||
-		!roots.Equal(cfg.LogRemoteTLSCAs) || cfg.LogRemoteBuffer != 500 ||
-		cfg.LogRemoteFacility != 3 || cfg.LogRemoteAppName != "fsn1app1/gitea" {
-		t.Errorf("remote log settings %v, %v, %d, %d and %q", cfg.LogRemoteURL,
-			cfg.LogRemoteTLSCAs, cfg.LogRemoteBuffer, cfg.LogRemoteFacility,
-			cfg.LogRemoteAppName)
-	}
-}
-
-func TestRemoteLogURLForms(t *testing.T) {
-	t.Parallel()
-
-	for _, value := range []string{
-		"syslog+udp://192.0.2.1:514",
-		"syslog+tcp://[2001:db8::1]:514",
-		"syslog+tls://logs.example:6514/",
-	} {
-		cfg := fromEnvironment(t, environment{logRemoteURL: value})
-		if cfg.LogRemoteURL.String() != value {
-			t.Errorf("%s read as %v", value, cfg.LogRemoteURL)
-		}
-	}
-
-	cfg := fromEnvironment(t, environment{logRemoteURL: ""})
-	if cfg.LogRemoteURL != nil {
-		t.Errorf("set but empty, %s read as %v", logRemoteURL, cfg.LogRemoteURL)
-	}
-}
-
-func TestRemoteLogFacilitiesByNumber(t *testing.T) {
-	t.Parallel()
-
-	for name, number := range map[string]int{
-		"kern": 0, "user": 1, "auth": 4, "authpriv": 10, "ftp": 11,
-		"local0": 16, "local5": 21, "local7": 23,
-	} {
-		cfg := fromEnvironment(t, environment{logRemoteFacility: name})
-		if cfg.LogRemoteFacility != number {
-			t.Errorf("%s read as %d, want %d", name, cfg.LogRemoteFacility, number)
-		}
-	}
-}
-
-func TestInvalidRemoteLogSettingStopsTheStart(t *testing.T) {
-	t.Parallel()
-
-	for _, tc := range []struct{ name, value string }{
-		{logRemoteURL, "logs.example:514"},
-		{logRemoteURL, "syslog://logs.example:514"},
-		{logRemoteURL, "http://logs.example:514"},
-		{logRemoteURL, "syslog+udp://logs.example"},
-		{logRemoteURL, "syslog+tcp://:514"},
-		{logRemoteURL, "syslog+tcp://logs.example:0"},
-		{logRemoteURL, "syslog+tls://logs.example:65536"},
-		{logRemoteURL, "syslog+tls://user@logs.example:6514"},
-		{logRemoteURL, "syslog+tcp://logs.example:514/app"},
-		{logRemoteURL, "syslog+tcp://logs.example:514?tls=1"},
-		{logRemoteTLSCAFile, "/nonexistent/ca.pem"},
-		{logRemoteBuffer, off}, {logRemoteBuffer, "0"}, {logRemoteBuffer, "10K"},
-		{logRemoteFacility, "local8"}, {logRemoteFacility, "LOCAL0"},
-		{logRemoteFacility, "16"}, {logRemoteFacility, ""},
-		{logRemoteAppName, ""}, {logRemoteAppName, "my app"},
-		{logRemoteAppName, "gitéa"}, {logRemoteAppName, strings.Repeat("a", 49)},
-	} {
-		_, err := config.FromEnvironment(environment{tc.name: tc.value}.lookupEnv)
-		if err == nil || !strings.HasPrefix(err.Error(), tc.name+": ") {
-			t.Errorf("%s=%q: error %v, want one naming it", tc.name, tc.value, err)
-		}
-	}
-}
-
-func TestRemoteLogCAFileWithoutCertificateStopsTheStart(t *testing.T) {
-	t.Parallel()
-
-	caFile := filepath.Join(t.TempDir(), "ca.pem")
-
-	err := os.WriteFile(caFile, []byte("not a certificate\n"), 0o600)
-	if err != nil {
-		t.Fatalf("write %s: %v", caFile, err)
-	}
-
-	_, err = config.FromEnvironment(environment{logRemoteTLSCAFile: caFile}.lookupEnv)
-
-	want := logRemoteTLSCAFile + `: "` + caFile + `" holds no PEM certificate`
-	if err == nil || err.Error() != want {
-		t.Errorf("error %v, want %s", err, want)
-	}
-}
-
 func TestCodeOnBothCountryListsStopsTheStart(t *testing.T) {
 	t.Parallel()
 
@@ -501,13 +366,14 @@ func TestInvalidValueStopsTheStart(t *testing.T) {
 		{banResponse, "404"}, {banResponse, "drop"}, {banResponse, ""},
 		{limitBanDuration, off}, {limitBanDuration, "0s"}, {limitBanDuration, "1"},
 		{limitBanRepeatWindow, off}, {limitBanRepeatWindow, "-1h"},
-		{maxBanDuration, off}, {maxBanDuration, "1w"},
+		{maxBanDuration, off}, {maxBanDuration, "1w"}, {attackBanDuration, off},
 		{maxBans, off}, {maxBans, "0"}, {maxBans, "5K"},
 		{banScopeV4Prefix, "33"}, {banScopeV4Prefix, "-1"}, {banScopeV4Prefix, "/24"},
 		{stateDir, ""}, {stateDir, "state"}, {stateDir, "./var/lib/smallwebwaf"},
 		{stateWriteDelay, off}, {stateWriteDelay, "0s"},
 		{stateCounterInterval, off}, {stateCounterInterval, "15"},
 		{metricsTopN, off}, {metricsTopN, "0"}, {metricsTopN, "-1"},
+		{rulesEnabled, "yes"}, {rulesEnabled, "True"},
 	} {
 		t.Run(tc.name+"="+tc.value, func(t *testing.T) {
 			t.Parallel()
@@ -575,8 +441,6 @@ func TestLogsEachSettingWithItsValue(t *testing.T) {
 		t.Fatalf("decode %s: %v", out.Bytes(), err)
 	}
 
-	hostname, _ := os.Hostname()
-
 	want := map[string]string{
 		listenAddr:              ":8080",
 		upstreamURL:             "http://127.0.0.1:8081",
@@ -602,6 +466,7 @@ func TestLogsEachSettingWithItsValue(t *testing.T) {
 		limitBanDuration:        "1h",
 		limitBanRepeatWindow:    "24h",
 		maxBanDuration:          "7d",
+		attackBanDuration:       "7d",
 		maxBans:                 "5000",
 		banScopeV4Prefix:        "32",
 		stateDir:                "/var/lib/smallwebwaf",
@@ -609,11 +474,8 @@ func TestLogsEachSettingWithItsValue(t *testing.T) {
 		stateCounterInterval:    "15m",
 		metricsToken:            "",
 		metricsTopN:             "50",
-		logRemoteURL:            "",
-		logRemoteTLSCAFile:      "",
-		logRemoteBuffer:         "10000",
-		logRemoteFacility:       "local0",
-		logRemoteAppName:        hostname,
+		rulesDir:                "/etc/smallwebwaf/rules.d",
+		rulesEnabled:            "true",
 	}
 	if !maps.Equal(line.Settings, want) {
 		t.Errorf("logged settings\n%v\nwant\n%v", line.Settings, want)
@@ -643,8 +505,8 @@ func wantSettings(t *testing.T, got *config.Config, want config.Config) {
 	wantBanSettings(t, got, want)
 }
 
-// wantBanSettings checks the settings for bans, the state files and the
-// metrics.
+// wantBanSettings checks the settings for bans, the state files, the
+// metrics and the rule files.
 func wantBanSettings(t *testing.T, got *config.Config, want config.Config) {
 	t.Helper()
 
@@ -652,11 +514,17 @@ func wantBanSettings(t *testing.T, got *config.Config, want config.Config) {
 		got.LimitBanDuration != want.LimitBanDuration ||
 		got.LimitBanRepeatWindow != want.LimitBanRepeatWindow ||
 		got.MaxBanDuration != want.MaxBanDuration ||
+		got.AttackBanDuration != want.AttackBanDuration ||
 		got.MaxBans != want.MaxBans ||
 		got.BanScopeV4Prefix != want.BanScopeV4Prefix {
 		t.Errorf("ban settings\n%+v\nwant\n%+v", got, want)
 	}
 
+	if got.RulesDir != want.RulesDir || got.RulesEnabled != want.RulesEnabled {
+		t.Errorf("rule files in %q, on: %t, want %q, %t",
+			got.RulesDir, got.RulesEnabled, want.RulesDir, want.RulesEnabled)
+	}
+
 	if got.StateDir != want.StateDir ||
 		got.StateWriteDelay != want.StateWriteDelay ||
 		got.StateCounterInterval != want.StateCounterInterval {

internal/metrics/metrics.go

@@ -13,8 +13,8 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"sneak.berlin/go/smallwebwaf/internal/bans"
 	"sneak.berlin/go/smallwebwaf/internal/ratelimit"
-	"sneak.berlin/go/smallwebwaf/internal/remotelog"
 	"sneak.berlin/go/smallwebwaf/internal/requestlog"
+	"sneak.berlin/go/smallwebwaf/internal/rules"
 )
 
 // Metrics are smallwebwaf's metrics. They are safe for concurrent use.
@@ -31,7 +31,9 @@ type Metrics struct {
 	rateLimitHits        *prometheus.CounterVec
 	sizeAndTimeLimitHits *prometheus.CounterVec
 	offences             *prometheus.CounterVec
-	countries            *countries
+	// ruleMatches are made by AddRules.
+	ruleMatches *prometheus.CounterVec
+	countries   *countries
 
 	// GeoJSRequests are the requests to GeoJS, and GeoJSFailures those
 	// that failed. GeoJSUnanswered are the requests whose client counted
@@ -136,19 +138,22 @@ func New(topN int) *Metrics {
 
 // AddBansAndClients adds the metrics read from the ledger and the table
 // of clients as the metrics are asked for: the bans made since the start,
-// the bans active and permanent at now, and the clients in the table.
+// by cause, the bans active and permanent at now, and the clients in the
+// table.
 func (m *Metrics) AddBansAndClients(
 	ledger *bans.Ledger, limiter *ratelimit.Limiter, now func() time.Time,
 ) {
-	m.registry.MustRegister(
-		// Every ban smallwebwaf makes so far is for a broken limit.
-		prometheus.NewCounterFunc(prometheus.CounterOpts{
+	for _, cause := range []string{bans.CauseLimit, bans.CauseAttack} {
+		m.registry.MustRegister(prometheus.NewCounterFunc(prometheus.CounterOpts{
 			Name:        "smallwebwaf_bans_made_total",
 			Help:        "Bans made, by cause.",
-			ConstLabels: prometheus.Labels{"cause": "limit"},
+			ConstLabels: prometheus.Labels{"cause": cause},
 		}, func() float64 {
-			return float64(ledger.Made())
-		}),
+			return float64(ledger.Made(cause))
+		}))
+	}
+
+	m.registry.MustRegister(
 		prometheus.NewGaugeFunc(prometheus.GaugeOpts{
 			Name: "smallwebwaf_active_bans",
 			Help: "Bans active now, the permanent ones included.",
@@ -174,31 +179,22 @@ func (m *Metrics) AddBansAndClients(
 	)
 }
 
-// AddRemoteLog adds the metrics of sending the log lines to
-// SWWAF_LOG_REMOTE_URL, read from remote as the metrics are asked for: the
-// lines sent, those dropped, and those waiting in the buffer.
-func (m *Metrics) AddRemoteLog(remote *remotelog.Sender) {
-	m.registry.MustRegister(
-		prometheus.NewCounterFunc(prometheus.CounterOpts{
-			Name: "smallwebwaf_remote_log_lines_sent_total",
-			Help: "Log lines sent to SWWAF_LOG_REMOTE_URL.",
-		}, func() float64 {
-			return float64(remote.Sent())
-		}),
-		prometheus.NewCounterFunc(prometheus.CounterOpts{
-			Name: "smallwebwaf_remote_log_lines_dropped_total",
-			Help: "Log lines dropped: the oldest in a full buffer, and those " +
-				"whose sending failed.",
-		}, func() float64 {
-			return float64(remote.Dropped())
-		}),
+// AddRules adds the metrics of the rule files: the requests that matched
+// each rule, which RuleMatched counts, and the rules loaded from
+// ruleFiles, read as the metrics are asked for. It is called once, before
+// RuleMatched.
+func (m *Metrics) AddRules(ruleFiles *rules.Files) {
+	m.ruleMatches = counterVec("smallwebwaf_rule_matches_total",
+		"Requests that matched a rule of the rule files, by its id and action.",
+		[]string{"rule_id", "action"})
+
+	m.registry.MustRegister(m.ruleMatches,
 		prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-			Name: "smallwebwaf_remote_log_buffer_depth",
-			Help: "Log lines in the buffer, waiting to be sent.",
+			Name: "smallwebwaf_rules_loaded",
+			Help: "Rules loaded from the rule files.",
 		}, func() float64 {
-			return float64(remote.Depth())
-		}),
-	)
+			return float64(ruleFiles.Len())
+		}))
 }
 
 // ServeHTTP answers with the metrics in the Prometheus text format.
@@ -247,6 +243,12 @@ func (m *Metrics) RequestEnded(
 	}
 }
 
+// RuleMatched counts a request that matched the rule id, whose action is
+// action.
+func (m *Metrics) RuleMatched(id, action string) {
+	m.ruleMatches.WithLabelValues(id, action).Inc()
+}
+
 // StateFileWritten counts a write of the state file name, of size bytes,
 // that ended with err.
 func (m *Metrics) StateFileWritten(name string, size int, err error) {

internal/proxy/bans.go

@@ -6,6 +6,7 @@ import (
 
 	"sneak.berlin/go/smallwebwaf/internal/bans"
 	"sneak.berlin/go/smallwebwaf/internal/requestlog"
+	"sneak.berlin/go/smallwebwaf/internal/rules"
 )
 
 // banResponse is a refusal answered with SWWAF_BAN_RESPONSE, and logged
@@ -51,20 +52,12 @@ func (rq *request) limitBroken(now time.Time) bool {
 
 	netblock := rq.netblock()
 	ban := rq.h.ledger.BanForLimit(netblock, now, bans.Notes{
-		Country: rq.line.Country,
-		Limit:   hit.Limit,
-		Window:  hit.Window,
-		Count:   hit.Requests,
-		Request: bans.Request{
-			Time:      now,
-			Method:    rq.in.Method,
-			Host:      rq.in.Host,
-			Path:      rq.in.URL.RequestURI(),
-			Status:    rq.h.config.BanResponse,
-			UserAgent: rq.in.UserAgent(),
-		},
-		// The histories count this request only once it has ended.
-		Requests: rq.h.limiter.Requests(netblock) + 1,
+		Country:  rq.line.Country,
+		Limit:    hit.Limit,
+		Window:   hit.Window,
+		Count:    hit.Requests,
+		Request:  rq.noted(now),
+		Requests: rq.netblockRequests(netblock),
 	})
 	rq.h.limiter.Reset(group)
 	rq.line.BanExpires = banExpires(ban)
@@ -72,6 +65,40 @@ func (rq *request) limitBroken(now time.Time) bool {
 	return true
 }
 
+// banForAttack bans the client's netblock at now for a clear sign of
+// attack, the match of rule, a ban rule.
+func (rq *request) banForAttack(now time.Time, rule rules.Rule) {
+	netblock := rq.netblock()
+	ban := rq.h.ledger.BanForAttack(netblock, now, bans.Notes{
+		Country:  rq.line.Country,
+		RuleID:   rule.ID,
+		Target:   rule.Target,
+		Request:  rq.noted(now),
+		Requests: rq.netblockRequests(netblock),
+	})
+	rq.line.BanExpires = banExpires(ban)
+}
+
+// noted is the request, refused at now with SWWAF_BAN_RESPONSE, as the
+// notes of the ban it makes keep it.
+func (rq *request) noted(now time.Time) bans.Request {
+	return bans.Request{
+		Time:      now,
+		Method:    rq.in.Method,
+		Host:      rq.in.Host,
+		Path:      rq.in.URL.RequestURI(),
+		Status:    rq.h.config.BanResponse,
+		UserAgent: rq.in.UserAgent(),
+	}
+}
+
+// netblockRequests is how many requests netblock has sent since it was
+// first seen, this one included: the histories count it only once it has
+// ended.
+func (rq *request) netblockRequests(netblock netip.Prefix) int64 {
+	return rq.h.limiter.Requests(netblock) + 1
+}
+
 // netblock is the netblock a ban on the client covers: its IPv4 address,
 // widened to SWWAF_BAN_SCOPE_V4_PREFIX, or the IPv6 group clientGroup
 // counts it in.

internal/proxy/bans_test.go

@@ -278,6 +278,7 @@ func TestBanNotes(t *testing.T) {
 		Netblock: netblock,
 		Start:    start,
 		Expires:  start.Add(time.Hour),
+		Cause:    bans.CauseLimit,
 		Notes: bans.Notes{
 			Country: "DE",
 			Limit:   1,
@@ -295,7 +296,7 @@ func TestBanNotes(t *testing.T) {
 			// refused under the ban.
 			Requests:    4,
 			Refused:     2,
-			EarlierBans: 0,
+			EarlierBans: bans.EarlierBans{},
 		},
 	}
 
@@ -312,8 +313,8 @@ func TestBanNotes(t *testing.T) {
 	s.get(fromDE, http.StatusForbidden, requestlog.ActionRateLimited)
 
 	got = ledger.Bans(netblock)
-	if len(got) != 2 || got[1].Notes.EarlierBans != 1 {
-		t.Errorf("bans %+v, want two, the second with one earlier ban", got)
+	if len(got) != 2 || got[1].Notes.EarlierBans != (bans.EarlierBans{Limit: 1}) {
+		t.Errorf("bans %+v, want two, the second with one earlier ban for a limit", got)
 	}
 }
 

internal/proxy/passthrough_test.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"io"
 	"net/http"
+	"reflect"
 	"slices"
 	"strings"
 	"sync/atomic"
@@ -128,7 +129,7 @@ func wantRequestFields(t *testing.T, line logLine, host string, sent, received i
 		Action: requestlog.ActionForward, DurationTotal: line.DurationTotal,
 		DurationUpstreamTotal: line.DurationUpstreamTotal,
 	}
-	if line.Line != want {
+	if !reflect.DeepEqual(line.Line, want) {
 		t.Errorf("log line\n%+v\nwant\n%+v", line.Line, want)
 	}
 

internal/proxy/proxy.go

@@ -17,6 +17,7 @@ import (
 	"sneak.berlin/go/smallwebwaf/internal/metrics"
 	"sneak.berlin/go/smallwebwaf/internal/ratelimit"
 	"sneak.berlin/go/smallwebwaf/internal/requestlog"
+	"sneak.berlin/go/smallwebwaf/internal/rules"
 )
 
 // How smallwebwaf keeps connections to the app open between requests.
@@ -51,6 +52,9 @@ type Params struct {
 	// limits, bans are made and run out, and GeoJS's answers are kept,
 	// normally time.Now in UTC, the time the state files give.
 	Now func() time.Time
+	// Rules are the rule files' rules, which each request is checked
+	// against.
+	Rules *rules.Files
 }
 
 // Server is the server smallwebwaf runs, with the parts of the proxy
@@ -90,6 +94,7 @@ func New(params Params) *Server {
 			LimitBanDuration:     params.Config.LimitBanDuration,
 			LimitBanRepeatWindow: params.Config.LimitBanRepeatWindow,
 			MaxBanDuration:       params.Config.MaxBanDuration,
+			AttackBanDuration:    params.Config.AttackBanDuration,
 			MaxBans:              params.Config.MaxBans,
 		}),
 		geojs: lookup.New(lookup.Params{
@@ -98,8 +103,10 @@ func New(params Params) *Server {
 			ProcessLog: params.ProcessLog,
 			Metrics:    m,
 		}),
+		rules: params.Rules,
 	}
 	m.AddBansAndClients(h.ledger, h.limiter, params.Now)
+	m.AddRules(params.Rules)
 
 	return &Server{
 		Server: &http.Server{
@@ -134,6 +141,7 @@ type handler struct {
 	limiter    *ratelimit.Limiter
 	ledger     *bans.Ledger
 	geojs      *lookup.GeoJS
+	rules      *rules.Files
 }
 
 // newTransport returns what carries requests to the app. It never goes

internal/proxy/proxy_test.go

@@ -17,6 +17,7 @@ import (
 	"sneak.berlin/go/smallwebwaf/internal/config"
 	"sneak.berlin/go/smallwebwaf/internal/proxy"
 	"sneak.berlin/go/smallwebwaf/internal/requestlog"
+	"sneak.berlin/go/smallwebwaf/internal/rules"
 )
 
 const (
@@ -67,6 +68,8 @@ const (
 	maxBanDuration          = "SWWAF_MAX_BAN_DURATION"
 	maxBans                 = "SWWAF_MAX_BANS"
 	banScopeV4Prefix        = "SWWAF_BAN_SCOPE_V4_PREFIX"
+	attackBanDuration       = "SWWAF_ATTACK_BAN_DURATION"
+	rulesDir                = "SWWAF_RULES_DIR"
 )
 
 // output collects what smallwebwaf writes on stdout.
@@ -197,14 +200,15 @@ func startProxyWithGeoJS(
 }
 
 // startProxyWithClock is startProxyWithGeoJS with requests counted and
-// bans made by the time now tells, and returns the server as well.
+// bans made by the time now tells, and returns the server as well. Unless
+// env sets SWWAF_RULES_DIR, it is an empty directory, of no rules.
 func startProxyWithClock(
 	t *testing.T, appURL, geojsURL string, now func() time.Time,
 	env map[string]string,
 ) (string, *output, *proxy.Server) {
 	t.Helper()
 
-	settings := map[string]string{"SWWAF_UPSTREAM_URL": appURL}
+	settings := map[string]string{"SWWAF_UPSTREAM_URL": appURL, rulesDir: t.TempDir()}
 	maps.Copy(settings, env)
 
 	cfg, err := config.FromEnvironment(func(name string) (string, bool) {
@@ -217,12 +221,22 @@ func startProxyWithClock(
 	}
 
 	out := &output{}
+	processLog := requestlog.NewProcessLogger(out)
+
+	ruleFiles, err := rules.Load(rules.Params{
+		Dir: cfg.RulesDir, Enabled: cfg.RulesEnabled, ProcessLog: processLog,
+	})
+	if err != nil {
+		t.Fatalf("rule files: %v", err)
+	}
+
 	server := proxy.New(proxy.Params{
 		Config:     cfg,
 		RequestLog: out,
-		ProcessLog: requestlog.NewProcessLogger(out),
+		ProcessLog: processLog,
 		GeoJSURL:   geojsURL,
 		Now:        now,
+		Rules:      ruleFiles,
 	})
 
 	listener, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", localhost+":0")

internal/proxy/request.go

@@ -110,20 +110,23 @@ func (h *handler) newRequest(w http.ResponseWriter, r *http.Request) *request {
 // check is the one place where a request can be refused once its client
 // is known, before its body is read or anything reaches the app. It
 // returns nil to let the request through. The checks of checkClient come
-// first, answered with SWWAF_BAN_RESPONSE, and then the size limit, so
-// that a request the rate limits count is counted even when it is
-// refused for its size. In observe mode a request checkClient refuses
-// goes on to the size limit like any other. ctx is the request's own
-// context.
+// first, answered with SWWAF_BAN_RESPONSE, or 403 for a block rule, and
+// then the size limit, so that a request the rate limits count is counted
+// even when it is refused for its size. In observe mode a request
+// checkClient refuses goes on to the size limit like any other. ctx is
+// the request's own context.
 func (rq *request) check(ctx context.Context) *refusal {
 	action := rq.checkClient(ctx)
-	if action != "" {
-		if !rq.h.config.Observe {
-			return rq.banResponse(action)
-		}
 
+	switch {
+	case action == "":
+	case rq.h.config.Observe:
 		// The log line names what enforce mode would have done.
 		rq.line.WouldAction = action
+	case action == requestlog.ActionRuleBlocked:
+		return &refusal{status: http.StatusForbidden, action: action}
+	default:
+		return rq.banResponse(action)
 	}
 
 	maxBytes := rq.h.config.RequestMaxBytes
@@ -145,8 +148,8 @@ func (rq *request) check(ctx context.Context) *refusal {
 // client either refuses is not looked up, and then the country lists; a
 // request any of them refuses is not counted for the rate limits. Then
 // come the rate limits, unless the client is in
-// SWWAF_RATE_LIMIT_EXEMPT_NETS, so that every other request is counted.
-// ctx is the request's own context.
+// SWWAF_RATE_LIMIT_EXEMPT_NETS, so that every other request is counted,
+// and last the rule files. ctx is the request's own context.
 func (rq *request) checkClient(ctx context.Context) string {
 	cfg := rq.h.config
 	if isInside(rq.client, cfg.AllowNets) {
@@ -171,7 +174,7 @@ func (rq *request) checkClient(ctx context.Context) string {
 		return requestlog.ActionRateLimited
 	}
 
-	return ""
+	return rq.checkRules(now)
 }
 
 // forward passes the request to the app and the app's answer back. ctx

internal/proxy/rulefiles_test.go

@@ -0,0 +1,232 @@
+package proxy_test
+
+import (
+	"net/http"
+	"net/netip"
+	"os"
+	"path/filepath"
+	"slices"
+	"testing"
+	"time"
+
+	"sneak.berlin/go/smallwebwaf/internal/bans"
+	"sneak.berlin/go/smallwebwaf/internal/requestlog"
+)
+
+// testRules are the rules most tests here load: a block rule for
+// /blocked and a ban rule for /.env.
+const testRules = `
+blocked  path  block  ^/blocked$
+probe    path  ban    ^/\.env$
+`
+
+func TestEachRuleAction(t *testing.T) {
+	t.Parallel()
+
+	s, clk, server := startWithClock(t, "", map[string]string{
+		rulesDir:    writeRules(t, "noted path log ^/\n"+testRules),
+		banResponse: "429",
+	})
+	start := clk.Now()
+
+	// A log rule notes its match, and lets the request through.
+	line := s.get(client, http.StatusOK, requestlog.ActionForward)
+	wantRuleIDs(t, line, "noted")
+
+	// A block rule refuses with 403, whatever SWWAF_BAN_RESPONSE is, and
+	// bans no one.
+	line = s.request(client, "/blocked", http.StatusForbidden,
+		requestlog.ActionRuleBlocked)
+	wantRuleIDs(t, line, "noted", "blocked")
+	s.get(client, http.StatusOK, requestlog.ActionForward)
+
+	// A ban rule refuses with SWWAF_BAN_RESPONSE, and bans the client for
+	// seven days, the default.
+	line = s.request(client, "/.env", http.StatusTooManyRequests, requestlog.ActionBanned)
+	wantRuleIDs(t, line, "noted", "probe")
+
+	if line.BanExpires != requestlog.FormatTime(start.Add(7*24*time.Hour)) {
+		t.Errorf("log line has ban_expires %q, want seven days on", line.BanExpires)
+	}
+
+	netblock := netip.MustParsePrefix(client + "/32")
+	want := bans.Ban{
+		Netblock: netblock,
+		Start:    start,
+		Expires:  start.Add(7 * 24 * time.Hour),
+		Cause:    bans.CauseAttack,
+		Notes: bans.Notes{
+			RuleID: "probe",
+			Target: "path",
+			Request: bans.Request{
+				Time:      start,
+				Method:    http.MethodGet,
+				Host:      appHost,
+				Path:      "/.env",
+				Status:    http.StatusTooManyRequests,
+				UserAgent: userAgent,
+			},
+			// The four requests up to and including the probe.
+			Requests: 4,
+		},
+	}
+
+	got := server.Ledger.Bans(netblock)
+	if len(got) != 1 || got[0] != want {
+		t.Fatalf("bans\n%+v\nwant\n%+v", got, want)
+	}
+
+	// The next request is refused under the ban, without being checked
+	// against the rules, and makes the ban permanent.
+	clk.advance(time.Hour)
+
+	line = s.get(client, http.StatusTooManyRequests, requestlog.ActionBanned)
+	wantRuleIDs(t, line)
+
+	if line.BanExpires != permanent {
+		t.Errorf("log line has ban_expires %q, want permanent", line.BanExpires)
+	}
+
+	clk.advance(365 * 24 * time.Hour)
+	s.get(client, http.StatusTooManyRequests, requestlog.ActionBanned)
+}
+
+func TestNextClearSignOfAttackAfterABanBansPermanently(t *testing.T) {
+	t.Parallel()
+
+	s, clk, _ := startWithClock(t, "", map[string]string{
+		rulesDir:          writeRules(t, testRules),
+		attackBanDuration: "1h",
+	})
+
+	// The first probe bans for SWWAF_ATTACK_BAN_DURATION.
+	line := s.request(client, "/.env", http.StatusForbidden, requestlog.ActionBanned)
+	if line.BanExpires != requestlog.FormatTime(clk.Now().Add(time.Hour)) {
+		t.Errorf("log line has ban_expires %q, want an hour on", line.BanExpires)
+	}
+
+	// Once that ban has run out without a request, the client is served,
+	// and its next probe bans it for good.
+	clk.advance(time.Hour)
+	s.get(client, http.StatusOK, requestlog.ActionForward)
+
+	line = s.request(client, "/.env", http.StatusForbidden, requestlog.ActionBanned)
+	if line.BanExpires != permanent {
+		t.Errorf("log line has ban_expires %q, want permanent", line.BanExpires)
+	}
+}
+
+func TestRulesComeAfterTheOtherChecks(t *testing.T) {
+	t.Parallel()
+
+	const (
+		allowed = "192.0.2.60" // in SWWAF_ALLOW_NETS
+		exempt  = "192.0.2.50" // in SWWAF_RATE_LIMIT_EXEMPT_NETS
+	)
+
+	s, _, server := startWithClock(t, "", map[string]string{
+		rulesDir:            writeRules(t, testRules),
+		allowNets:           allowed,
+		rateLimitExemptNets: exempt,
+		rateLimitPerMinute:  "1",
+	})
+
+	// A client in SWWAF_ALLOW_NETS is not checked.
+	line := s.request(allowed, "/.env", http.StatusOK, requestlog.ActionForward)
+	wantRuleIDs(t, line)
+
+	// A probe over the rate limit breaks the limit before any rule sees
+	// it.
+	s.get(client, http.StatusOK, requestlog.ActionForward)
+	line = s.request(client, "/.env", http.StatusForbidden, requestlog.ActionRateLimited)
+	wantRuleIDs(t, line)
+
+	limitBan := server.Ledger.Bans(netip.MustParsePrefix(client + "/32"))
+	if len(limitBan) != 1 || limitBan[0].Cause != bans.CauseLimit {
+		t.Errorf("bans %+v, want one for a broken limit", limitBan)
+	}
+
+	// A client the rate limits do not apply to is still checked.
+	s.get(exempt, http.StatusOK, requestlog.ActionForward)
+	s.request(exempt, "/.env", http.StatusForbidden, requestlog.ActionBanned)
+}
+
+func TestObserveModeLogsWhatTheRulesWouldDo(t *testing.T) {
+	t.Parallel()
+
+	s, _, server := startWithClock(t, "", map[string]string{
+		rulesDir: writeRules(t, testRules),
+		mode:     observe,
+	})
+
+	line := s.request(client, "/blocked", http.StatusOK, requestlog.ActionForward)
+	wantWouldAction(t, line, requestlog.ActionRuleBlocked)
+	wantRuleIDs(t, line, "blocked")
+
+	line = s.request(client, "/.env", http.StatusOK, requestlog.ActionForward)
+	wantWouldAction(t, line, requestlog.ActionBanned)
+	wantRuleIDs(t, line, "probe")
+
+	if line.BanExpires != "" {
+		t.Errorf("log line has ban_expires %q, want none", line.BanExpires)
+	}
+
+	// No ban was made.
+	line = s.get(client, http.StatusOK, requestlog.ActionForward)
+	wantWouldAction(t, line, "")
+
+	if got := server.Ledger.Snapshot(); len(got) != 0 {
+		t.Errorf("bans %+v, want none", got)
+	}
+}
+
+func TestMetricsCountRuleMatchesAndBansForAnAttack(t *testing.T) {
+	t.Parallel()
+
+	const scraper = "192.0.2.200"
+
+	s, _, _ := startWithClock(t, "", map[string]string{
+		rulesDir:     writeRules(t, testRules),
+		metricsToken: token,
+	})
+
+	s.request(client, "/blocked", http.StatusForbidden, requestlog.ActionRuleBlocked)
+	s.request(client, "/.env", http.StatusForbidden, requestlog.ActionBanned)
+	s.get(client, http.StatusForbidden, requestlog.ActionBanned)
+
+	metrics := s.scrape(scraper)
+	wantMetric(t, metrics,
+		`smallwebwaf_rule_matches_total{action="block",rule_id="blocked"}`, 1)
+	wantMetric(t, metrics,
+		`smallwebwaf_rule_matches_total{action="ban",rule_id="probe"}`, 1)
+	wantMetric(t, metrics, "smallwebwaf_rules_loaded", 2)
+	wantMetric(t, metrics,
+		`smallwebwaf_requests_total{action="rule_blocked",status_class="4xx"}`, 1)
+	wantMetric(t, metrics, `smallwebwaf_bans_made_total{cause="attack"}`, 1)
+	wantMetric(t, metrics, `smallwebwaf_bans_made_total{cause="limit"}`, 0)
+	wantMetric(t, metrics, "smallwebwaf_permanent_bans", 1)
+}
+
+// writeRules writes content as a rule file into a new directory, and
+// returns the directory.
+func writeRules(t *testing.T, content string) string {
+	t.Helper()
+
+	dir := t.TempDir()
+
+	err := os.WriteFile(filepath.Join(dir, "test.rules"), []byte(content), 0o600)
+	if err != nil {
+		t.Fatalf("write the rule file: %v", err)
+	}
+
+	return dir
+}
+
+// wantRuleIDs checks the request log line's rule_ids.
+func wantRuleIDs(t *testing.T, line logLine, want ...string) {
+	t.Helper()
+
+	if !slices.Equal(line.RuleIDs, want) {
+		t.Errorf("log line has rule_ids %v, want %v", line.RuleIDs, want)
+	}
+}

internal/proxy/rules.go

@@ -0,0 +1,40 @@
+package proxy
+
+import (
+	"time"
+
+	"sneak.berlin/go/smallwebwaf/internal/requestlog"
+	"sneak.berlin/go/smallwebwaf/internal/rules"
+)
+
+// checkRules checks the request against the rules of the rule files at
+// now, notes the ids of those it matches in the log line, and returns the
+// action of the rule that refuses it, ActionRuleBlocked for a block rule
+// and ActionBanned for a ban rule, or "" when none does. In enforce mode
+// a ban rule bans the client's netblock for a clear sign of attack.
+func (rq *request) checkRules(now time.Time) string {
+	matched := rq.h.rules.Match(rq.in)
+
+	for _, rule := range matched {
+		rq.line.RuleIDs = append(rq.line.RuleIDs, rule.ID)
+		rq.h.metrics.RuleMatched(rule.ID, rule.Action)
+	}
+
+	if len(matched) == 0 {
+		return ""
+	}
+
+	// Only the last rule matched can refuse the request.
+	switch last := matched[len(matched)-1]; last.Action {
+	case rules.ActionBlock:
+		return requestlog.ActionRuleBlocked
+	case rules.ActionBan:
+		if !rq.h.config.Observe {
+			rq.banForAttack(now, last)
+		}
+
+		return requestlog.ActionBanned
+	default:
+		return ""
+	}
+}

internal/remotelog/remotelog.go

@@ -1,296 +0,0 @@
-// Package remotelog sends the lines smallwebwaf writes on stdout to the
-// remote log endpoint, SWWAF_LOG_REMOTE_URL, as the "Request log" section
-// of SPEC.md describes: each line as the message of an RFC 5424 syslog
-// record, over UDP, TCP or TLS. Lines wait in a bounded buffer, so a slow
-// or unreachable endpoint never holds up a request or stdout.
-package remotelog
-
-import (
-	"bytes"
-	"context"
-	"crypto/tls"
-	"crypto/x509"
-	"fmt"
-	"log/slog"
-	"net"
-	"net/url"
-	"os"
-	"strconv"
-	"sync/atomic"
-	"time"
-
-	"sneak.berlin/go/smallwebwaf/internal/requestlog"
-)
-
-// The forms of SWWAF_LOG_REMOTE_URL, by its scheme.
-const (
-	SchemeUDP = "syslog+udp"
-	SchemeTCP = "syslog+tcp"
-	SchemeTLS = "syslog+tls"
-)
-
-// A record's priority is the number of its facility times the number of
-// severities there are, plus the number of its severity. Every record's
-// severity is informational.
-const (
-	severities    = 8
-	informational = 6
-)
-
-const (
-	// dialTimeout bounds connecting to the endpoint, the TLS handshake
-	// included.
-	dialTimeout = 10 * time.Second
-	// After a failed attempt to connect, the next is made a second later,
-	// and retryDelayFactor times as long after each further failure in a
-	// row, up to a minute.
-	firstRetryDelay  = time.Second
-	retryDelayFactor = 2
-	maxRetryDelay    = time.Minute
-)
-
-// Params are what New needs.
-type Params struct {
-	// URL is the endpoint (SWWAF_LOG_REMOTE_URL): SchemeUDP, SchemeTCP or
-	// SchemeTLS, a host and a port.
-	URL *url.URL
-	// RootCAs are the certificates a SchemeTLS endpoint's certificate
-	// must chain to (SWWAF_LOG_REMOTE_TLS_CA_FILE), nil for the host's.
-	RootCAs *x509.CertPool
-	// Buffer is the most lines held while they wait to be sent
-	// (SWWAF_LOG_REMOTE_BUFFER).
-	Buffer int
-	// Facility is the number of the records' syslog facility
-	// (SWWAF_LOG_REMOTE_FACILITY), and AppName their APP-NAME
-	// (SWWAF_LOG_REMOTE_APP_NAME).
-	Facility int
-	AppName  string
-}
-
-// Sender sends lines to the endpoint. Write puts them in its buffer, and
-// Run sends them from there.
-type Sender struct {
-	url       *url.URL
-	tlsConfig *tls.Config
-	// beforeTime and afterTime are the parts of every record's header
-	// before and after its time, as RFC 5424 lays the header out.
-	beforeTime string
-	afterTime  string
-	// records is the buffer: each line's record, framed to be sent.
-	records chan []byte
-	sent    atomic.Int64
-	dropped atomic.Int64
-}
-
-// New returns a Sender for the endpoint params.URL.
-func New(params Params) *Sender {
-	hostname, err := os.Hostname()
-	if err != nil || hostname == "" {
-		hostname = "-" // RFC 5424's value for a field that has none
-	}
-
-	priority := params.Facility*severities + informational
-
-	return &Sender{
-		url: params.URL,
-		tlsConfig: &tls.Config{
-			RootCAs:    params.RootCAs,
-			MinVersion: tls.VersionTLS12,
-		},
-		// The 1 is the version of the format. The process id, the message
-		// id and the structured data have no value.
-		beforeTime: "<" + strconv.Itoa(priority) + ">1 ",
-		afterTime:  " " + hostname + " " + params.AppName + " - - - ",
-		records:    make(chan []byte, params.Buffer),
-	}
-}
-
-// Write puts each line in p in the buffer, as the message of a record of
-// its own, and never waits: when the buffer is full, the oldest record in
-// it is dropped to make room. It is safe for concurrent use.
-func (s *Sender) Write(p []byte) (int, error) {
-	at := requestlog.FormatTime(time.Now())
-
-	for line := range bytes.Lines(p) {
-		line = bytes.TrimSuffix(line, []byte("\n"))
-		if len(line) > 0 {
-			s.put(s.record(at, line))
-		}
-	}
-
-	return len(p), nil
-}
-
-// Sent is how many records have been sent.
-func (s *Sender) Sent() int64 {
-	return s.sent.Load()
-}
-
-// Dropped is how many records were dropped: the oldest in a full buffer,
-// and those whose sending failed.
-func (s *Sender) Dropped() int64 {
-	return s.dropped.Load()
-}
-
-// Depth is how many records are in the buffer.
-func (s *Sender) Depth() int {
-	return len(s.records)
-}
-
-// Run connects to the endpoint and sends each record as it comes into the
-// buffer, until ctx is done. Then it sends the records still in the buffer,
-// on the connection open at that time or, if there is none, on a new one,
-// until none is left or one fails, and returns. How long it may take over
-// that is for the caller to bound.
-//
-// A connection on which a record fails is closed, the record dropped, and
-// a new one made at once. A failed attempt to connect is logged to
-// processLog and followed by the next after firstRetryDelay,
-// retryDelayFactor times as long after each further failure in a row up
-// to maxRetryDelay. Meanwhile the records wait in the buffer.
-func (s *Sender) Run(ctx context.Context, processLog *slog.Logger) {
-	conn := s.send(ctx, processLog)
-	if conn == nil && len(s.records) > 0 {
-		conn, _ = s.dial(context.WithoutCancel(ctx))
-	}
-
-	if conn == nil {
-		return
-	}
-
-	defer func() {
-		_ = conn.Close()
-	}()
-
-	for {
-		select {
-		case record := <-s.records:
-			if s.write(conn, record) != nil {
-				return
-			}
-		default:
-			return
-		}
-	}
-}
-
-// record returns line as an RFC 5424 record made at the time at, framed
-// for the endpoint: on its own over UDP, since each datagram holds one,
-// and over TCP and TLS after its length in bytes and a space, the
-// octet-counted framing of RFC 6587 and RFC 5425.
-func (s *Sender) record(at string, line []byte) []byte {
-	record := make([]byte, 0, len(s.beforeTime)+len(at)+len(s.afterTime)+len(line))
-	record = append(record, s.beforeTime...)
-	record = append(record, at...)
-	record = append(record, s.afterTime...)
-	record = append(record, line...)
-
-	if s.url.Scheme == SchemeUDP {
-		return record
-	}
-
-	return append([]byte(strconv.Itoa(len(record))+" "), record...)
-}
-
-// put adds record to the buffer, first dropping the oldest record in it
-// while it is full.
-func (s *Sender) put(record []byte) {
-	for {
-		select {
-		case s.records <- record:
-			return
-		default:
-		}
-
-		select {
-		case <-s.records:
-			s.dropped.Add(1)
-		default:
-		}
-	}
-}
-
-// send connects to the endpoint and sends each record as it comes into
-// the buffer, until ctx is done, and returns the connection then open, or
-// nil.
-func (s *Sender) send(ctx context.Context, processLog *slog.Logger) net.Conn {
-	delay := firstRetryDelay
-
-	for {
-		conn, err := s.dial(ctx)
-
-		switch {
-		case ctx.Err() != nil:
-			return conn
-		case err != nil:
-			processLog.Warn("connecting to SWWAF_LOG_REMOTE_URL failed",
-				"error", err.Error(), "connecting_again_in", delay.String())
-
-			select {
-			case <-time.After(delay):
-			case <-ctx.Done():
-				return nil
-			}
-
-			delay = min(retryDelayFactor*delay, maxRetryDelay)
-
-			continue
-		}
-
-		delay = firstRetryDelay
-
-		err = s.sendOn(ctx, conn)
-		if err == nil {
-			return conn
-		}
-
-		_ = conn.Close()
-	}
-}
-
-// sendOn sends each record on conn as it comes into the buffer, until one
-// fails, whose error it returns, or ctx is done.
-func (s *Sender) sendOn(ctx context.Context, conn net.Conn) error {
-	for {
-		select {
-		case record := <-s.records:
-			err := s.write(conn, record)
-			if err != nil {
-				return err
-			}
-		case <-ctx.Done():
-			return nil
-		}
-	}
-}
-
-// write sends record on conn, and counts it as sent or, if that fails,
-// as dropped.
-func (s *Sender) write(conn net.Conn, record []byte) error {
-	_, err := conn.Write(record)
-	if err != nil {
-		s.dropped.Add(1)
-
-		return fmt.Errorf("send a record: %w", err)
-	}
-
-	s.sent.Add(1)
-
-	return nil
-}
-
-// dial connects to the endpoint.
-func (s *Sender) dial(ctx context.Context) (net.Conn, error) {
-	dialer := &net.Dialer{Timeout: dialTimeout}
-
-	switch s.url.Scheme {
-	case SchemeUDP:
-		return dialer.DialContext(ctx, "udp", s.url.Host)
-	case SchemeTLS:
-		tlsDialer := &tls.Dialer{NetDialer: dialer, Config: s.tlsConfig}
-
-		return tlsDialer.DialContext(ctx, "tcp", s.url.Host)
-	default:
-		return dialer.DialContext(ctx, "tcp", s.url.Host)
-	}
-}

internal/remotelog/remotelog_test.go

@@ -1,458 +0,0 @@
-package remotelog_test
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/tls"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log/slog"
-	"math/big"
-	"net"
-	"net/url"
-	"os"
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-	"testing"
-	"testing/synctest"
-	"time"
-
-	"sneak.berlin/go/smallwebwaf/internal/remotelog"
-)
-
-// The tests run in a synctest bubble, where the time package runs on a
-// clock of the test's own, which starts at 2000-01-01T00:00:00Z: a wait
-// lasts exactly as long as it should, however slowly the test process
-// runs, and synctest.Wait returns once the sender has done all it can
-// before time passes. The endpoint is a listener on the loopback address.
-// A test reads from it only once the records are on their way, and checks
-// the sender's counts first, since a goroutine of the bubble that waits on
-// the network keeps that clock from moving on.
-
-const (
-	// started is the time a record made as a test starts gives.
-	started = "2000-01-01T00:00:00.000Z"
-	appName = "fsn1app1/gitea"
-	// local0 is the number of the default facility, and local0Info the
-	// priority of its records.
-	local0     = 16
-	local0Info = "<134>"
-	// loopback is where the endpoints listen.
-	loopback = "127.0.0.1:0"
-)
-
-func TestRecordsOverUDPGoOnePerDatagram(t *testing.T) {
-	t.Parallel()
-
-	synctest.Test(t, func(t *testing.T) {
-		endpoint, err := (&net.ListenConfig{}).ListenPacket(t.Context(), "udp", loopback)
-		if err != nil {
-			t.Fatalf("listen: %v", err)
-		}
-
-		t.Cleanup(func() { _ = endpoint.Close() })
-
-		sender, _, _ := run(t, params(remotelog.SchemeUDP, endpoint.LocalAddr()))
-
-		_, _ = sender.Write([]byte(`{"type":"request"}` + "\n" + `{"type":"process"}` + "\n"))
-
-		synctest.Wait()
-		wantCounts(t, sender, 2, 0, 0)
-
-		for _, line := range []string{`{"type":"request"}`, `{"type":"process"}`} {
-			datagram := make([]byte, 1024)
-
-			n, _, err := endpoint.ReadFrom(datagram)
-			if err != nil {
-				t.Fatalf("read: %v", err)
-			}
-
-			want := record(t, local0Info, appName, line)
-			if string(datagram[:n]) != want {
-				t.Errorf("datagram %q, want %q", datagram[:n], want)
-			}
-		}
-	})
-}
-
-func TestRecordsOverTCPAreOctetCountedWithTheirFacility(t *testing.T) {
-	t.Parallel()
-
-	synctest.Test(t, func(t *testing.T) {
-		endpoint := listen(t, loopback)
-		endpointParams := params(remotelog.SchemeTCP, endpoint.Addr())
-		endpointParams.Facility = 19 // local3
-		endpointParams.AppName = "gitea"
-		sender, _, _ := run(t, endpointParams)
-
-		_, _ = sender.Write([]byte("first\nsecond\n"))
-
-		synctest.Wait()
-		wantCounts(t, sender, 2, 0, 0)
-
-		frames := bufio.NewReader(accept(t, endpoint))
-		wantFrame(t, frames, record(t, "<158>", "gitea", "first"))
-		wantFrame(t, frames, record(t, "<158>", "gitea", "second"))
-	})
-}
-
-func TestStalledEndpointHoldsUpNoWriteAndOldestRecordsAreDropped(t *testing.T) {
-	t.Parallel()
-
-	synctest.Test(t, func(t *testing.T) {
-		certificate, roots := testCertificate(t)
-		endpoint := listen(t, loopback)
-		endpointParams := params(remotelog.SchemeTLS, endpoint.Addr())
-		endpointParams.RootCAs = roots
-		endpointParams.Buffer = 3
-		sender, _, _ := run(t, endpointParams)
-
-		// The sender connects, and its TLS handshake waits for an answer
-		// the endpoint does not give yet.
-		conn := accept(t, endpoint)
-
-		var stdout bytes.Buffer
-
-		out := io.MultiWriter(&stdout, sender)
-		for i := range 5 {
-			_, _ = fmt.Fprintf(out, "line %d\n", i+1)
-		}
-
-		if stdout.String() != "line 1\nline 2\nline 3\nline 4\nline 5\n" {
-			t.Errorf("stdout has %q", stdout.String())
-		}
-
-		wantCounts(t, sender, 0, 2, 3)
-
-		// Once the endpoint answers, the three newest records are sent.
-		server := tls.Server(conn, &tls.Config{
-			Certificates: []tls.Certificate{certificate},
-			MinVersion:   tls.VersionTLS12,
-		})
-
-		err := server.HandshakeContext(t.Context())
-		if err != nil {
-			t.Fatalf("handshake: %v", err)
-		}
-
-		synctest.Wait()
-		wantCounts(t, sender, 3, 2, 0)
-
-		frames := bufio.NewReader(server)
-		for _, line := range []string{"line 3", "line 4", "line 5"} {
-			wantFrame(t, frames, record(t, local0Info, appName, line))
-		}
-	})
-}
-
-func TestReconnectsWithBackoffAfterTheEndpointGoesAway(t *testing.T) {
-	t.Parallel()
-
-	synctest.Test(t, func(t *testing.T) {
-		endpoint := listen(t, loopback)
-		addr := endpoint.Addr()
-		sender, logged, _ := run(t, params(remotelog.SchemeTCP, addr))
-
-		_, _ = sender.Write([]byte("one\n"))
-
-		synctest.Wait()
-		wantCounts(t, sender, 1, 0, 0)
-
-		conn := accept(t, endpoint)
-		wantFrame(t, bufio.NewReader(conn), record(t, local0Info, appName, "one"))
-
-		// The endpoint goes away. The sender notices when a record fails,
-		// and tries to connect again at once, then a second later, then two
-		// seconds after that.
-		_ = conn.Close()
-		_ = endpoint.Close()
-
-		writeUntilDropped(t, sender, 1)
-		sent := sender.Sent()
-
-		_, _ = sender.Write([]byte("two\n"))
-
-		time.Sleep(time.Second)
-		synctest.Wait()
-
-		endpoint = listen(t, addr.String())
-
-		time.Sleep(2*time.Second - time.Nanosecond)
-		synctest.Wait()
-		wantCounts(t, sender, sent, 1, 1)
-
-		// The endpoint is back, and the record waiting is sent.
-		time.Sleep(time.Nanosecond)
-		synctest.Wait()
-		wantCounts(t, sender, sent+1, 1, 0)
-
-		conn = accept(t, endpoint)
-		wantFrame(t, bufio.NewReader(conn), record(t, local0Info, appName, "two"))
-		wantRetries(t, logged, "1s", "2s")
-
-		// Having connected, the sender waits a second again after the
-		// next failure.
-		_ = conn.Close()
-		_ = endpoint.Close()
-
-		writeUntilDropped(t, sender, 2)
-		wantRetries(t, logged, "1s", "2s", "1s")
-	})
-}
-
-func TestRecordsWaitingAtTheStopAreSent(t *testing.T) {
-	t.Parallel()
-
-	synctest.Test(t, func(t *testing.T) {
-		// Nothing listens at addr when the sender starts: it fails to
-		// connect, and waits a second to try again.
-		endpoint := listen(t, loopback)
-		addr := endpoint.Addr()
-		_ = endpoint.Close()
-
-		sender, logged, stop := run(t, params(remotelog.SchemeTCP, addr))
-
-		synctest.Wait()
-		wantRetries(t, logged, "1s")
-
-		_, _ = sender.Write([]byte("one\ntwo\n"))
-		endpoint = listen(t, addr.String())
-
-		// Stopped before that second is over, it connects to send them.
-		stop()
-		wantCounts(t, sender, 2, 0, 0)
-
-		frames := bufio.NewReader(accept(t, endpoint))
-		wantFrame(t, frames, record(t, local0Info, appName, "one"))
-		wantFrame(t, frames, record(t, local0Info, appName, "two"))
-	})
-}
-
-// output collects what the sender logs.
-type output struct {
-	mu  sync.Mutex
-	buf bytes.Buffer
-}
-
-// Write adds lines the sender logs.
-func (o *output) Write(p []byte) (int, error) {
-	o.mu.Lock()
-	defer o.mu.Unlock()
-
-	return o.buf.Write(p)
-}
-
-// text returns everything logged so far.
-func (o *output) text() string {
-	o.mu.Lock()
-	defer o.mu.Unlock()
-
-	return o.buf.String()
-}
-
-// params returns the settings of a Sender for the endpoint at addr, in
-// the form scheme names: room for ten lines, the default facility, and
-// appName.
-func params(scheme string, addr net.Addr) remotelog.Params {
-	return remotelog.Params{
-		URL:      &url.URL{Scheme: scheme, Host: addr.String()},
-		Buffer:   10,
-		Facility: local0,
-		AppName:  appName,
-	}
-}
-
-// run runs a Sender with settings until the test ends or the function
-// it returns is called, which waits for Run to return. It returns the
-// Sender, and what it logs.
-func run(t *testing.T, settings remotelog.Params) (*remotelog.Sender, *output, func()) {
-	t.Helper()
-
-	sender := remotelog.New(settings)
-	logged := &output{}
-	ctx, cancel := context.WithCancel(t.Context())
-	ran := make(chan struct{})
-
-	go func() {
-		sender.Run(ctx, slog.New(slog.NewJSONHandler(logged, nil)))
-		close(ran)
-	}()
-
-	stop := func() {
-		cancel()
-		<-ran
-	}
-	t.Cleanup(stop)
-
-	return sender, logged, stop
-}
-
-// listen returns a TCP listener at addr, closed when the test ends.
-func listen(t *testing.T, addr string) net.Listener {
-	t.Helper()
-
-	listener, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", addr)
-	if err != nil {
-		t.Fatalf("listen: %v", err)
-	}
-
-	t.Cleanup(func() { _ = listener.Close() })
-
-	return listener
-}
-
-// accept returns the next connection to listener, closed when the test
-// ends.
-func accept(t *testing.T, listener net.Listener) net.Conn {
-	t.Helper()
-
-	conn, err := listener.Accept()
-	if err != nil {
-		t.Fatalf("accept: %v", err)
-	}
-
-	t.Cleanup(func() { _ = conn.Close() })
-
-	return conn
-}
-
-// record returns the record of line made as the test started, with the
-// priority and the app name given.
-func record(t *testing.T, priority, app, line string) string {
-	t.Helper()
-
-	hostname, err := os.Hostname()
-	if err != nil || hostname == "" {
-		hostname = "-"
-	}
-
-	return priority + "1 " + started + " " + hostname + " " + app + " - - - " + line
-}
-
-// wantFrame reads the next octet-counted frame from frames, and checks
-// that it holds want.
-func wantFrame(t *testing.T, frames *bufio.Reader, want string) {
-	t.Helper()
-
-	count, err := frames.ReadString(' ')
-	if err != nil {
-		t.Fatalf("read a frame's length: %v", err)
-	}
-
-	length, err := strconv.Atoi(strings.TrimSuffix(count, " "))
-	if err != nil {
-		t.Fatalf("frame starts %q, not with its length", count)
-	}
-
-	got := make([]byte, length)
-
-	_, err = io.ReadFull(frames, got)
-	if err != nil {
-		t.Fatalf("read a frame: %v", err)
-	}
-
-	if string(got) != want {
-		t.Errorf("frame %q, want %q", got, want)
-	}
-}
-
-// wantCounts checks the records sender has sent, dropped and holds in
-// its buffer.
-func wantCounts(
-	t *testing.T, sender *remotelog.Sender, sent, dropped int64, depth int,
-) {
-	t.Helper()
-
-	if sender.Sent() != sent || sender.Dropped() != dropped || sender.Depth() != depth {
-		t.Fatalf("sent %d, dropped %d, %d in the buffer; want %d, %d and %d",
-			sender.Sent(), sender.Dropped(), sender.Depth(), sent, dropped, depth)
-	}
-}
-
-// writeUntilDropped writes a line at a time until the count of records
-// sender has dropped reaches dropped. The records it sends on a
-// connection the endpoint has closed are lost before one fails; how many
-// depends on when the endpoint's host answers that the connection is
-// gone.
-func writeUntilDropped(t *testing.T, sender *remotelog.Sender, dropped int64) {
-	t.Helper()
-
-	for sender.Dropped() < dropped {
-		_, _ = sender.Write([]byte("lost\n"))
-
-		synctest.Wait()
-	}
-}
-
-// wantRetries checks that the sender logged a failed attempt to connect
-// for each of delays, the time until the next attempt, in order, and
-// logged nothing else.
-func wantRetries(t *testing.T, logged *output, delays ...string) {
-	t.Helper()
-
-	var got []string
-
-	for line := range strings.Lines(logged.text()) {
-		var fields map[string]any
-
-		err := json.Unmarshal([]byte(line), &fields)
-		if err != nil || fields["msg"] != "connecting to SWWAF_LOG_REMOTE_URL failed" {
-			t.Fatalf("logged %q", line)
-		}
-
-		delay, _ := fields["connecting_again_in"].(string)
-		got = append(got, delay)
-	}
-
-	if !slices.Equal(got, delays) {
-		t.Errorf("logged failures to connect again in %v, want %v", got, delays)
-	}
-}
-
-// testCertificate returns a certificate for 127.0.0.1 that is its own
-// CA, and a pool that holds it.
-func testCertificate(t *testing.T) (tls.Certificate, *x509.CertPool) {
-	t.Helper()
-
-	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		t.Fatalf("generate a key: %v", err)
-	}
-
-	template := &x509.Certificate{
-		SerialNumber:          big.NewInt(1),
-		Subject:               pkix.Name{CommonName: "smallwebwaf test CA"},
-		NotBefore:             time.Now().Add(-time.Hour),
-		NotAfter:              time.Now().Add(time.Hour),
-		IsCA:                  true,
-		BasicConstraintsValid: true,
-		KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		IPAddresses:           []net.IP{net.IPv4(127, 0, 0, 1)},
-	}
-
-	der, err := x509.CreateCertificate(rand.Reader, template, template,
-		&key.PublicKey, key)
-	if err != nil {
-		t.Fatalf("create a certificate: %v", err)
-	}
-
-	certificate, err := x509.ParseCertificate(der)
-	if err != nil {
-		t.Fatalf("parse the certificate: %v", err)
-	}
-
-	roots := x509.NewCertPool()
-	roots.AddCert(certificate)
-
-	return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: key}, roots
-}

internal/requestlog/requestlog.go

@@ -26,8 +26,12 @@ const (
 	// ActionRateLimited is a request refused because it took its client
 	// over a rate limit, which bans the client.
 	ActionRateLimited = "rate_limited"
-	// ActionBanned is a request refused because a ban covers its client.
+	// ActionBanned is a request refused because a ban covers its client,
+	// or because it matched a ban rule, which bans the client.
 	ActionBanned = "banned"
+	// ActionRuleBlocked is a request refused because it matched a block
+	// rule.
+	ActionRuleBlocked = "rule_blocked"
 	// ActionDenied is a request refused because its client is in
 	// SWWAF_DENY_NETS.
 	ActionDenied = "denied"
@@ -69,8 +73,11 @@ type Line struct {
 	Action         string `json:"action"`
 	// WouldAction is, in observe mode, the action enforce mode would have
 	// taken with a request it would have refused: ActionDenied,
-	// ActionBanned, ActionCountryDenied or ActionRateLimited.
+	// ActionBanned, ActionCountryDenied, ActionRateLimited or
+	// ActionRuleBlocked.
 	WouldAction string `json:"would_action,omitempty"`
+	// RuleIDs are the ids of the rule file rules the request matched.
+	RuleIDs []string `json:"rule_ids,omitempty"`
 	// LimitHit is the window whose rate limit the request went over:
 	// minute, hour or day.
 	LimitHit string `json:"limit_hit,omitempty"`

internal/rules/rules.go

@@ -0,0 +1,415 @@
+// Package rules reads the rule files: the plain text files in
+// SWWAF_RULES_DIR, one rule to a line, that each request is checked
+// against, as the "Rule files" section of SPEC.md describes. They are read
+// at start, and again whenever one is edited, added or removed.
+package rules
+
+import (
+	"context"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"strings"
+	"sync/atomic"
+
+	"github.com/fsnotify/fsnotify"
+)
+
+// The actions a rule takes when it matches.
+const (
+	// ActionLog notes the match in the request log, and does nothing else.
+	ActionLog = "log"
+	// ActionBlock refuses the request with 403.
+	ActionBlock = "block"
+	// ActionBan refuses the request and bans the client's netblock: the
+	// request is a clear sign of attack.
+	ActionBan = "ban"
+)
+
+// extension ends the name of every rule file.
+const extension = ".rules"
+
+// headerTarget starts the target that is one request header,
+// header:<Name>.
+const headerTarget = "header:"
+
+// escapeLength is the length of a percent escape, such as %2e.
+const escapeLength = 3
+
+var (
+	// ruleLine is a rule: four fields separated by spaces or tabs, of
+	// which the fourth, the regex, runs to the end of the line.
+	ruleLine = regexp.MustCompile(`^([^ \t]+)[ \t]+([^ \t]+)[ \t]+([^ \t]+)[ \t]+(.+)$`)
+	// idChars are the characters of a rule's id.
+	idChars = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)
+)
+
+var (
+	errNotRule = errors.New(
+		"is not a rule: an id, a target, an action and a regex, " +
+			"separated by spaces or tabs")
+	errNotID     = errors.New("is not an id of letters, digits, - and _")
+	errNotTarget = errors.New(
+		"is not path, query, uri, method, host, user_agent, referer or header:<Name>")
+	errNotAction = errors.New("is not log, block or ban")
+	errNotRegex  = errors.New("does not compile")
+	errUsedTwice = errors.New("is already the id of the rule at")
+)
+
+// Rule is one rule of a rule file.
+type Rule struct {
+	// ID names the rule in the request log, the metrics and ban notes.
+	ID string
+	// Target is what the regex is matched against, such as path or
+	// header:Accept.
+	Target string
+	// Action is ActionLog, ActionBlock or ActionBan.
+	Action string
+
+	regex *regexp.Regexp
+}
+
+// Params are what Load needs.
+type Params struct {
+	// Dir is the directory of the rule files (SWWAF_RULES_DIR).
+	Dir string
+	// Enabled is SWWAF_RULES_ENABLED: while it is false, no file is read
+	// and no rule loaded.
+	Enabled bool
+	// ProcessLog receives how many rules were read, and the error in a
+	// rule file edited while smallwebwaf runs.
+	ProcessLog *slog.Logger
+}
+
+// Files are the rule files of a running smallwebwaf, and the rules read
+// from them. They are safe for concurrent use.
+type Files struct {
+	params Params
+	// rules are the rules loaded, in the order of their files' names, and
+	// then of their lines.
+	rules atomic.Pointer[[]Rule]
+}
+
+// Load reads the rules of every *.rules file in Dir, in the order of the
+// files' names, unless Enabled is false. A Dir that cannot be read is an
+// error, and so is a line that is not a rule, a regex that does not
+// compile and an id used twice, each named with its file and line.
+func Load(params Params) (*Files, error) {
+	f := &Files{params: params}
+	f.rules.Store(&[]Rule{})
+
+	if !params.Enabled {
+		return f, nil
+	}
+
+	rules, err := read(params.Dir)
+	if err != nil {
+		return nil, err
+	}
+
+	f.rules.Store(&rules)
+	f.logRead(len(rules))
+
+	return f, nil
+}
+
+// Match checks r against the rules, in order, and returns those it
+// matches, up to the first whose action refuses it, block or ban, which
+// is then the last one returned.
+func (f *Files) Match(r *http.Request) []Rule {
+	var matched []Rule
+
+	for _, rule := range *f.rules.Load() {
+		if !rule.matches(r) {
+			continue
+		}
+
+		matched = append(matched, rule)
+		if rule.Action != ActionLog {
+			break
+		}
+	}
+
+	return matched
+}
+
+// Len returns how many rules are loaded.
+func (f *Files) Len() int {
+	return len(*f.rules.Load())
+}
+
+// Watch watches Dir until ctx is done, and reads the rule files again
+// whenever one is edited, added or removed. If they then hold an error,
+// the rules stay as they were, the error is logged with its file and
+// line, and the files are read again at the next change. If Dir cannot be
+// watched, that is logged, and the rules stay as they were loaded. While
+// Enabled is false, Watch returns at once.
+func (f *Files) Watch(ctx context.Context) {
+	if !f.params.Enabled {
+		return
+	}
+
+	watcher, err := fsnotify.NewWatcher()
+	if err == nil {
+		defer func() {
+			_ = watcher.Close()
+		}()
+
+		err = watcher.Add(f.params.Dir)
+	}
+
+	if err != nil {
+		f.params.ProcessLog.Error("cannot watch the rule files for edits",
+			"error", err.Error())
+
+		return
+	}
+
+	f.params.ProcessLog.Info("watching the rule files for edits",
+		"directory", f.params.Dir)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case event := <-watcher.Events:
+			if filepath.Ext(event.Name) == extension {
+				f.readAgain()
+			}
+		case err = <-watcher.Errors:
+			f.params.ProcessLog.Warn("watching the rule files failed",
+				"error", err.Error())
+		}
+	}
+}
+
+// readAgain reads the rule files again, in place of the rules loaded, or
+// logs the error that keeps the rules as they were.
+func (f *Files) readAgain() {
+	rules, err := read(f.params.Dir)
+	if err != nil {
+		f.params.ProcessLog.Error(
+			"a rule file has an error, and the rules stay as they were",
+			"error", err.Error())
+
+		return
+	}
+
+	f.rules.Store(&rules)
+	f.logRead(len(rules))
+}
+
+// logRead logs that the rule files were read, and how many rules they
+// hold, which can be none.
+func (f *Files) logRead(count int) {
+	f.params.ProcessLog.Info("read the rule files",
+		"directory", f.params.Dir, "rules", count)
+}
+
+// read returns the rules of every rule file in dir, in the order of the
+// files' names, and then of their lines.
+func read(dir string) ([]Rule, error) {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, fmt.Errorf("SWWAF_RULES_DIR cannot be read: %w", err)
+	}
+
+	var rules []Rule
+
+	// places are where each id is, as "<file>, line <n>".
+	places := map[string]string{}
+
+	for _, entry := range entries {
+		if entry.IsDir() || filepath.Ext(entry.Name()) != extension {
+			continue
+		}
+
+		rules, err = readFile(filepath.Join(dir, entry.Name()), rules, places)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return rules, nil
+}
+
+// readFile appends the rules of the rule file at path to rules. places
+// are where each id read so far is, and gain those of the file.
+func readFile(path string, rules []Rule, places map[string]string) ([]Rule, error) {
+	data, err := os.ReadFile(path) //nolint:gosec // a rule file, in SWWAF_RULES_DIR
+	if err != nil {
+		return nil, err
+	}
+
+	number := 0
+
+	for line := range strings.Lines(string(data)) {
+		number++
+		place := fmt.Sprintf("%s, line %d", path, number)
+
+		text := strings.TrimSuffix(strings.TrimSuffix(line, "\n"), "\r")
+
+		rule, isRule, err := parse(text)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", place, err)
+		}
+
+		if !isRule {
+			continue
+		}
+
+		first, used := places[rule.ID]
+		if used {
+			return nil, fmt.Errorf("%s: the id %q %w %s", place, rule.ID, errUsedTwice, first)
+		}
+
+		places[rule.ID] = place
+		rules = append(rules, rule)
+	}
+
+	return rules, nil
+}
+
+// parse reads a line of a rule file. It returns false for a blank line
+// and for a comment, a line that starts with #.
+func parse(line string) (Rule, bool, error) {
+	line = strings.TrimLeft(line, " \t")
+	if line == "" || strings.HasPrefix(line, "#") {
+		return Rule{}, false, nil
+	}
+
+	fields := ruleLine.FindStringSubmatch(line)
+	if fields == nil {
+		return Rule{}, false, errNotRule
+	}
+
+	rule := Rule{ID: fields[1], Target: fields[2], Action: fields[3]}
+
+	switch {
+	case !idChars.MatchString(rule.ID):
+		return Rule{}, false, fmt.Errorf("the id %q %w", rule.ID, errNotID)
+	case !isTarget(rule.Target):
+		return Rule{}, false, fmt.Errorf("the target %q %w", rule.Target, errNotTarget)
+	case !slices.Contains([]string{ActionLog, ActionBlock, ActionBan}, rule.Action):
+		return Rule{}, false, fmt.Errorf("the action %q %w", rule.Action, errNotAction)
+	}
+
+	regex, err := regexp.Compile(fields[4])
+	if err != nil {
+		return Rule{}, false, fmt.Errorf("the regex %w: %w", errNotRegex, err)
+	}
+
+	rule.regex = regex
+
+	return rule, true, nil
+}
+
+// isTarget reports whether target is one a rule may have.
+func isTarget(target string) bool {
+	switch target {
+	case "path", "query", "uri", "method", "host", "user_agent", "referer":
+		return true
+	}
+
+	name, isHeader := strings.CutPrefix(target, headerTarget)
+
+	return isHeader && name != ""
+}
+
+// matches reports whether the rule's regex matches its target in r. For
+// uri it is matched against the path and query as received, and against
+// them once percent-decoded, so that an encoded probe cannot slip past.
+func (rule Rule) matches(r *http.Request) bool {
+	if rule.Target == "uri" {
+		uri := pathAndQuery(r)
+
+		return rule.regex.MatchString(uri) || rule.regex.MatchString(decodeOnce(uri))
+	}
+
+	return rule.regex.MatchString(value(rule.Target, r))
+}
+
+// value returns what a rule with target, other than uri, is matched
+// against in r: the path and the query as the client sent them, before
+// any decoding or re-encoding, split at the first ?, and a header's values
+// joined by ", ", as HTTP joins those of a header sent more than once.
+func value(target string, r *http.Request) string {
+	switch target {
+	case "path":
+		path, _, _ := strings.Cut(pathAndQuery(r), "?")
+
+		return path
+	case "query":
+		_, query, _ := strings.Cut(pathAndQuery(r), "?")
+
+		return query
+	case "method":
+		return r.Method
+	case "host":
+		return r.Host
+	case "user_agent":
+		return header(r, "User-Agent")
+	case "referer":
+		return header(r, "Referer")
+	default:
+		return header(r, strings.TrimPrefix(target, headerTarget))
+	}
+}
+
+// pathAndQuery returns the path and the query of r as the client sent
+// them: the target of its request line, r.RequestURI, of which a target
+// in absolute form, http://host/path as a client sends it to a proxy,
+// gives what follows the host. r.URL is not used: when the path holds a
+// character it escapes, such as \ or a non-ASCII byte, it decodes the
+// whole path and escapes it again, so that \ becomes %5C and %2e a dot.
+func pathAndQuery(r *http.Request) string {
+	if !r.URL.IsAbs() {
+		return r.RequestURI
+	}
+
+	_, afterScheme, _ := strings.Cut(r.RequestURI, "://")
+
+	start := strings.IndexAny(afterScheme, "/?")
+	if start < 0 {
+		return ""
+	}
+
+	return afterScheme[start:]
+}
+
+// header returns the values of r's header name joined by ", ", or "" if
+// r has no such header.
+func header(r *http.Request, name string) string {
+	return strings.Join(r.Header.Values(name), ", ")
+}
+
+// decodeOnce returns s with each percent escape, such as %2e, replaced by
+// the byte it stands for. A % that is not followed by two hex digits is
+// left as it is, so that a malformed escape cannot keep the rest of s
+// from being decoded.
+func decodeOnce(s string) string {
+	var decoded strings.Builder
+
+	for i := 0; i < len(s); i++ {
+		if s[i] == '%' && i+escapeLength <= len(s) {
+			b, err := hex.DecodeString(s[i+1 : i+escapeLength])
+			if err == nil {
+				decoded.Write(b)
+
+				i += escapeLength - 1
+
+				continue
+			}
+		}
+
+		decoded.WriteByte(s[i])
+	}
+
+	return decoded.String()
+}

internal/rules/rules_test.go

@@ -0,0 +1,595 @@
+package rules_test
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"maps"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"testing"
+
+	"sneak.berlin/go/smallwebwaf/internal/rules"
+)
+
+const (
+	// What the process log says once Watch watches the directory, after
+	// each reading of the rule files, and for one that has an error.
+	watching = "watching the rule files for edits"
+	read     = "read the rule files"
+	hasError = "a rule file has an error, and the rules stay as they were"
+	// maxLogLines is how many lines of the process log wait for a test to
+	// read them.
+	maxLogLines = 64
+	// browser is the user agent of an ordinary visitor.
+	browser = "Mozilla/5.0 (X11; Linux x86_64; rv:140.0) Gecko/20100101 Firefox/140.0"
+	// testFile is the rule file of a test that needs only one, and
+	// firstFile the first of a test's rule files.
+	testFile  = "test.rules"
+	firstFile = "00-a.rules"
+	// userAgent is the header that carries the user agent.
+	userAgent = "User-Agent"
+)
+
+func TestEachTargetMatchesWhatItNames(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		name   string
+		rule   string // its target, action and regex
+		uri    string // the request's path and query
+		header http.Header
+		want   bool
+	}{
+		{"path as received", `path log ^/%2eenv$`, "/%2eenv", nil, true},
+		{"path not decoded", `path log ^/\.env$`, "/%2eenv", nil, false},
+		{"path without the query", `path log ^/a$`, "/a?b=c", nil, true},
+		{"query as received", `query log ^b=%2e$`, "/a?b=%2e", nil, true},
+		{"uri as received", `uri log ^/a\?b=%2e$`, "/a?b=%2e", nil, true},
+		{"uri decoded", `uri log (\.\./){2}`, "/a?f=%2e%2e%2f%2e%2e%2f", nil, true},
+		{
+			"uri decoded past malformed escapes", `uri log (\.\./){2}&h=%$`,
+			"/a?g=%zz&f=%2e%2e%2f%2e%2e%2f&h=%", nil, true,
+		},
+		{"uri decoded only once", `uri log ^/a\.b$`, "/a%252eb", nil, false},
+		{"method", `method log ^PUT$`, "/", nil, true},
+		{"host", `host log ^app\.example$`, "/", nil, true},
+		{
+			"user_agent", `user_agent log ^sqlmap/`, "/",
+			http.Header{userAgent: {"sqlmap/1.8"}}, true,
+		},
+		{
+			"user_agent sent twice", `user_agent log ^curl/8, sqlmap/`, "/",
+			http.Header{userAgent: {"curl/8", "sqlmap/1.8"}}, true,
+		},
+		{"user_agent missing", `user_agent log ^$`, "/", nil, true},
+		{
+			"referer", `referer log ^https://spam\.example/`, "/",
+			http.Header{"Referer": {"https://spam.example/buy"}}, true,
+		},
+		{
+			"a header sent twice", `header:x-api-version log ^2, 3$`, "/",
+			http.Header{"X-Api-Version": {"2", "3"}}, true,
+		},
+		{"a header missing", `header:X-Api-Version log ^$`, "/", nil, true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			files := load(t, ruleFiles{testFile: "a-rule " + tc.rule + "\n"})
+
+			// Every request is a PUT, which the method rule looks for.
+			r := httptest.NewRequestWithContext(t.Context(), http.MethodPut,
+				"http://app.example"+tc.uri, nil)
+			maps.Copy(r.Header, tc.header)
+
+			got := len(files.Match(r)) == 1
+			if got != tc.want {
+				t.Errorf("%s matches %s: %t, want %t", tc.rule, tc.uri, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestPathMatchedAsTheClientSentIt(t *testing.T) {
+	t.Parallel()
+
+	// Each path holds a character Go's URL type would escape again, \ or
+	// a non-ASCII byte, and each rule is written for the path as sent.
+	for _, tc := range []struct {
+		rule string // its target, action and regex
+		sent string // the path and query the client sent
+	}{
+		{`path log ^/\.\.\\\.\.\\windows\\win\.ini$`, `/..\..\windows\win.ini`},
+		{`path log ^/%2e%2e\\%2e%2e\\windows\\win\.ini$`, `/%2e%2e\%2e%2e\windows\win.ini`},
+		{`path log ^/café$`, "/café?x=1"},
+		{`uri log ^/%2e%2e\\%2e%2e\\boot\.ini\?x=1$`, `/%2e%2e\%2e%2e\boot.ini?x=1`},
+	} {
+		files := load(t, ruleFiles{testFile: "as-sent " + tc.rule + "\n"})
+
+		// The target in origin form, as traefik sends it, and in absolute
+		// form, as a client sends it to a proxy.
+		for _, target := range []string{tc.sent, "http://app.example" + tc.sent} {
+			r := httptest.NewRequestWithContext(t.Context(), http.MethodGet, target, nil)
+			wantMatched(t, files, r, "as-sent")
+		}
+	}
+}
+
+func TestMatchingStopsAtTheFirstRuleThatRefuses(t *testing.T) {
+	t.Parallel()
+
+	files := load(t, ruleFiles{testFile: `
+every-path     path  log    ^/
+no-path        path  log    ^$
+first-refusal  path  block  ^/probe
+later-ban      path  ban    ^/probe
+after          path  log    ^/
+`})
+
+	// Every log rule that matches is noted, and the block rule ends the
+	// matching.
+	wantMatched(t, files, get(t, "/probe"), "every-path", "first-refusal")
+	wantMatched(t, files, get(t, "/page"), "every-path", "after")
+
+	// A ban rule ends it too.
+	files = load(t, ruleFiles{testFile: "ban path ban ^/\nlater path block ^/\n"})
+	wantMatched(t, files, get(t, "/"), "ban")
+}
+
+func TestFilesReadInNameOrderThenLineOrder(t *testing.T) {
+	t.Parallel()
+
+	files := load(t, ruleFiles{
+		"50-b.rules": "b1 path log ^/\n\n# a comment\n  # an indented one\nb2 path log ^/\n",
+		firstFile:    "a1 path log ^/\r\n",
+		// None is a rule file.
+		"notes.txt":       "notes, not rules\n",
+		"10-c.rules.bak":  "an old copy\n",
+		"20-d.rules/keep": "a file in a directory\n",
+	})
+
+	wantMatched(t, files, get(t, "/"), "a1", "b1", "b2")
+
+	if files.Len() != 3 {
+		t.Errorf("%d rules loaded, want 3", files.Len())
+	}
+}
+
+func TestFaultStopsTheStartNamingTheFileAndLine(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		name    string
+		content string
+		line    int
+		want    string
+	}{
+		{
+			"too few fields", "env-file path ban\n", 1,
+			"is not a rule: an id, a target, an action and a regex, " +
+				"separated by spaces or tabs",
+		},
+		{
+			"an id of other characters", "# ids\n\nenv.file path ban ^/\n", 3,
+			`the id "env.file" is not an id of letters, digits, - and _`,
+		},
+		{
+			"an unknown target", "env-file paths ban ^/\n", 1,
+			`the target "paths" is not path, query, uri, method, host, ` +
+				"user_agent, referer or header:<Name>",
+		},
+		{
+			"a header without a name", "env-file header: ban ^/\n", 1,
+			`the target "header:" is not path, query, uri, method, host, ` +
+				"user_agent, referer or header:<Name>",
+		},
+		{
+			"an unknown action", "env-file path deny ^/\n", 1,
+			`the action "deny" is not log, block or ban`,
+		},
+		{
+			"a regex that does not compile", "env-file path ban ^/(\n", 1,
+			"the regex does not compile: error parsing regexp: " +
+				"missing closing ): `^/(`",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			dir := writeFiles(t, ruleFiles{"00-default.rules": tc.content})
+			path := filepath.Join(dir, "00-default.rules")
+
+			wantRefused(t, dir, path+", line "+strconv.Itoa(tc.line)+": "+tc.want)
+		})
+	}
+}
+
+func TestIDUsedTwiceStopsTheStartNamingBothPlaces(t *testing.T) {
+	t.Parallel()
+
+	dir := writeFiles(t, ruleFiles{
+		"00-a.rules": "probe path log ^/a\n",
+		"50-b.rules": "other path log ^/b\nprobe path ban ^/c\n",
+	})
+
+	wantRefused(t, dir, filepath.Join(dir, "50-b.rules")+`, line 2: the id "probe" `+
+		"is already the id of the rule at "+filepath.Join(dir, "00-a.rules")+", line 1")
+}
+
+func TestDirectoryThatDoesNotExistStopsTheStart(t *testing.T) {
+	t.Parallel()
+
+	dir := filepath.Join(t.TempDir(), "rules.d")
+
+	wantRefused(t, dir, "SWWAF_RULES_DIR cannot be read: open "+dir+
+		": no such file or directory")
+}
+
+func TestEmptyDirectoryLoadsNoRulesAndSaysSo(t *testing.T) {
+	t.Parallel()
+
+	params, lines := newParams(writeFiles(t, ruleFiles{"00-default.rules": "# none\n"}))
+
+	files, err := rules.Load(params)
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+
+	line := lines.waitFor(t, read)
+	if files.Len() != 0 || line["rules"] != 0.0 {
+		t.Errorf("%d rules loaded, and the log says %v, want none", files.Len(), line)
+	}
+}
+
+func TestRuleFilesOffReadNothing(t *testing.T) {
+	t.Parallel()
+
+	// SWWAF_RULES_DIR does not exist, which would stop the start.
+	params, _ := newParams(filepath.Join(t.TempDir(), "rules.d"))
+	params.Enabled = false
+
+	files, err := rules.Load(params)
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+
+	if files.Len() != 0 || files.Match(get(t, "/")) != nil {
+		t.Errorf("%d rules loaded with the rule files off", files.Len())
+	}
+
+	// It would watch until the test ends.
+	files.Watch(t.Context())
+}
+
+func TestEditsTakenInWhileRunning(t *testing.T) {
+	t.Parallel()
+
+	dir := writeFiles(t, ruleFiles{firstFile: "first path block ^/first\n"})
+	files, lines := watch(t, dir)
+
+	// matches reports whether path matches a rule.
+	matches := func(path string) bool { return len(files.Match(get(t, path))) == 1 }
+
+	// A file added.
+	save(t, dir, "50-b.rules", "second path block ^/second\n")
+	lines.waitUntil(t, func() bool { return matches("/second") })
+	wantMatched(t, files, get(t, "/first"), "first")
+
+	// A file edited.
+	save(t, dir, firstFile, "first path block ^/edited\n")
+	lines.waitUntil(t, func() bool { return !matches("/first") })
+	wantMatched(t, files, get(t, "/edited"), "first")
+
+	// A file removed.
+	err := os.Remove(filepath.Join(dir, "50-b.rules"))
+	if err != nil {
+		t.Fatalf("remove: %v", err)
+	}
+
+	lines.waitUntil(t, func() bool { return !matches("/second") })
+	wantMatched(t, files, get(t, "/edited"), "first")
+}
+
+func TestBrokenEditKeepsTheRulesAsTheyWere(t *testing.T) {
+	t.Parallel()
+
+	dir := writeFiles(t, ruleFiles{firstFile: "first path block ^/first\n"})
+	files, lines := watch(t, dir)
+
+	// The edit's second line has an unknown action, so the rules stay as
+	// they were, the first line's earlier version included.
+	save(t, dir, firstFile, "first path block ^/edited\nsecond path bann ^/second\n")
+
+	line := lines.waitFor(t, hasError)
+	want := filepath.Join(dir, firstFile) +
+		`, line 2: the action "bann" is not log, block or ban`
+
+	if line["error"] != want || line["level"] != "ERROR" {
+		t.Errorf("logged %v, want an error %q", line, want)
+	}
+
+	wantMatched(t, files, get(t, "/first"), "first")
+	wantMatched(t, files, get(t, "/second"))
+
+	// Once mended, the file is read again.
+	save(t, dir, firstFile, "first path block ^/edited\nsecond path ban ^/second\n")
+	lines.waitUntil(t, func() bool { return len(files.Match(get(t, "/second"))) == 1 })
+	wantMatched(t, files, get(t, "/edited"), "first")
+}
+
+func TestDefaultFileBansProbesAtTheSiteRootAlone(t *testing.T) {
+	t.Parallel()
+
+	params, _ := newParams(filepath.Join("..", "..", "share", "rules.d"))
+
+	files, err := rules.Load(params)
+	if err != nil {
+		t.Fatalf("load the default file: %v", err)
+	}
+
+	// Probes sent by a browser, by the rule that refuses them.
+	for rule, targets := range map[string][]string{
+		"env-file":    {"/.env", "/.env.production", "/.ENV"},
+		"vcs-dir":     {"/.git/config", "/.git", "/.svn/entries"},
+		"secrets-dir": {"/.aws/credentials", "/.ssh/id_rsa"},
+		"secret-file": {"/.htpasswd", "/.DS_Store", "/.git-credentials"},
+		"editor-dir":  {"/.vscode/sftp.json"},
+		"backup-file": {
+			"/wp-config.php.bak", "/index.php~", "/dump.sql", "/backup.sql.gz",
+		},
+		"log-file":     {"/debug.log"},
+		"compose-file": {"/docker-compose.yml", "/compose.yaml"},
+		"php-shell":    {"/shell.php"},
+		"path-traversal": {
+			"/static/../../etc/passwd", "/f?f=%2e%2e%2f%2e%2e%2fetc%2fpasswd",
+		},
+	} {
+		for _, target := range targets {
+			wantRefusedBy(t, files, target, browser, rule)
+		}
+	}
+
+	// Scanners, by their user agents.
+	for _, scanner := range []string{
+		"sqlmap/1.8.4#stable (https://sqlmap.org)",
+		"Mozilla/5.0 (compatible; Nuclei - Open-source project)",
+	} {
+		wantRefusedBy(t, files, "/", scanner, "scanner-agent")
+	}
+
+	// Ordinary requests to a code forge for files of those names deeper
+	// in its paths, and for other files at its root.
+	for _, target := range []string{
+		"/owner/repo/src/branch/main/.env.example",
+		"/owner/repo/src/branch/main/.env",
+		"/owner/repo/src/branch/main/.github/workflows/ci.yml",
+		"/owner/repo/src/branch/main/.vscode/settings.json",
+		"/owner/repo/src/branch/main/.htaccess",
+		"/owner/repo/src/branch/main/docker-compose.yml",
+		"/owner/repo/src/branch/main/db/schema.sql",
+		"/owner/repo/raw/branch/main/debug.log",
+		"/owner/repo.git/info/refs?service=git-upload-pack",
+		"/owner/repo/src/branch/main/docs/../README.md",
+		"/user/login?redirect_to=%2fowner%2frepo",
+		"/index.php",
+		"/.well-known/security.txt",
+	} {
+		r := get(t, target)
+		r.Header.Set(userAgent, browser)
+
+		matched := files.Match(r)
+		if len(matched) != 0 {
+			t.Errorf("%s matched %v, want no rule", target, ids(matched))
+		}
+	}
+
+	// A request without a user agent is only noted.
+	wantMatched(t, files, get(t, "/"), "empty-agent")
+}
+
+// ruleFiles are files to write into a directory of rule files, by name.
+type ruleFiles map[string]string
+
+// writeFiles writes files into a new directory, and returns it.
+func writeFiles(t *testing.T, files ruleFiles) string {
+	t.Helper()
+
+	dir := t.TempDir()
+
+	for name, content := range files {
+		path := filepath.Join(dir, name)
+
+		err := os.MkdirAll(filepath.Dir(path), 0o700)
+		if err != nil {
+			t.Fatalf("mkdir: %v", err)
+		}
+
+		err = os.WriteFile(path, []byte(content), 0o600)
+		if err != nil {
+			t.Fatalf("write %s: %v", name, err)
+		}
+	}
+
+	return dir
+}
+
+// save writes content to the rule file name in dir as an editor that
+// saves by renaming does, so that the file is never seen half written.
+func save(t *testing.T, dir, name, content string) {
+	t.Helper()
+
+	path := filepath.Join(dir, name)
+
+	err := os.WriteFile(path+".tmp", []byte(content), 0o600)
+	if err != nil {
+		t.Fatalf("write %s: %v", name, err)
+	}
+
+	err = os.Rename(path+".tmp", path)
+	if err != nil {
+		t.Fatalf("rename: %v", err)
+	}
+}
+
+// newParams returns Params for the rule files in dir, switched on, with
+// the process log in the processLog returned.
+func newParams(dir string) (rules.Params, processLog) {
+	lines := make(processLog, maxLogLines)
+
+	return rules.Params{
+		Dir:        dir,
+		Enabled:    true,
+		ProcessLog: slog.New(slog.NewJSONHandler(lines, nil)),
+	}, lines
+}
+
+// load writes files into a new directory and loads the rules in it.
+func load(t *testing.T, files ruleFiles) *rules.Files {
+	t.Helper()
+
+	params, _ := newParams(writeFiles(t, files))
+	params.ProcessLog = slog.New(slog.DiscardHandler)
+
+	loaded, err := rules.Load(params)
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+
+	return loaded
+}
+
+// watch loads the rules in dir, runs their Watch until the test ends, and
+// waits until it watches the directory.
+func watch(t *testing.T, dir string) (*rules.Files, processLog) {
+	t.Helper()
+
+	params, lines := newParams(dir)
+
+	files, err := rules.Load(params)
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+
+	ctx, stop := context.WithCancel(t.Context())
+	stopped := make(chan struct{})
+
+	go func() {
+		files.Watch(ctx)
+		close(stopped)
+	}()
+
+	t.Cleanup(func() {
+		stop()
+		<-stopped
+	})
+
+	lines.waitFor(t, watching)
+
+	return files, lines
+}
+
+// wantRefused checks that loading the rule files in dir fails with the
+// error want.
+func wantRefused(t *testing.T, dir, want string) {
+	t.Helper()
+
+	params, _ := newParams(dir)
+
+	_, err := rules.Load(params)
+	if err == nil || err.Error() != want {
+		t.Errorf("error %v, want %s", err, want)
+	}
+}
+
+// get returns a GET request for target, a path and an optional query, as
+// smallwebwaf's server reads it, without a user agent.
+func get(t *testing.T, target string) *http.Request {
+	t.Helper()
+
+	return httptest.NewRequestWithContext(t.Context(), http.MethodGet,
+		"http://app.example"+target, nil)
+}
+
+// wantRefusedBy checks that a GET request for target with the user agent
+// sent matches rule alone, and that rule refuses it.
+func wantRefusedBy(t *testing.T, files *rules.Files, target, sent, rule string) {
+	t.Helper()
+
+	r := get(t, target)
+	r.Header.Set(userAgent, sent)
+
+	matched := files.Match(r)
+	if len(matched) != 1 || matched[0].ID != rule || matched[0].Action == rules.ActionLog {
+		t.Errorf("%s from %q matched %v, want %s alone, refusing it", target,
+			sent, ids(matched), rule)
+	}
+}
+
+// wantMatched checks the ids of the rules r matches, in order.
+func wantMatched(t *testing.T, files *rules.Files, r *http.Request, want ...string) {
+	t.Helper()
+
+	got := ids(files.Match(r))
+	if !slices.Equal(got, want) {
+		t.Errorf("%s matched %v, want %v", r.URL, got, want)
+	}
+}
+
+// ids returns the ids of matched.
+func ids(matched []rules.Rule) []string {
+	got := make([]string, 0, len(matched))
+	for _, rule := range matched {
+		got = append(got, rule.ID)
+	}
+
+	return got
+}
+
+// processLog receives the lines of a process log, each a JSON object, for
+// a test to wait for.
+type processLog chan string
+
+// Write receives a line of the process log.
+func (l processLog) Write(line []byte) (int, error) {
+	l <- string(line)
+
+	return len(line), nil
+}
+
+// waitFor returns the next line of the process log whose message is msg,
+// passing over the lines before it. It waits as long as that takes, so
+// that a slow test process cannot fail the test.
+func (l processLog) waitFor(t *testing.T, msg string) map[string]any {
+	t.Helper()
+
+	for line := range l {
+		var fields map[string]any
+
+		err := json.Unmarshal([]byte(line), &fields)
+		if err != nil {
+			t.Fatalf("process log line %q is not JSON: %v", line, err)
+		}
+
+		if fields["msg"] == msg {
+			return fields
+		}
+	}
+
+	return nil
+}
+
+// waitUntil waits for the rule files to be read until done reports true,
+// as it does once they have been read after the test's last change. One
+// change can be seen more than once, and so read more than once.
+func (l processLog) waitUntil(t *testing.T, done func() bool) {
+	t.Helper()
+
+	for !done() {
+		l.waitFor(t, read)
+	}
+}

internal/smallwebwaf/healthcheck_test.go

@@ -28,6 +28,7 @@ func TestHealthCheck(t *testing.T) {
 		listenAddr:  localhost + ":0",
 		upstreamURL: app.URL,
 		stateDir:    t.TempDir(),
+		rulesDir:    t.TempDir(),
 	}
 
 	go func() {

internal/smallwebwaf/smallwebwaf.go

@@ -1,6 +1,6 @@
-// Package smallwebwaf runs the smallwebwaf process: it reads the settings
-// and the state files, serves requests until it is told to stop, and then
-// stops in an orderly way, writing the state files.
+// Package smallwebwaf runs the smallwebwaf process: it reads the settings,
+// the rule files and the state files, serves requests until it is told to
+// stop, and then stops in an orderly way, writing the state files.
 package smallwebwaf
 
 import (
@@ -18,8 +18,8 @@ import (
 	"sneak.berlin/go/smallwebwaf/internal/config"
 	"sneak.berlin/go/smallwebwaf/internal/lookup"
 	"sneak.berlin/go/smallwebwaf/internal/proxy"
-	"sneak.berlin/go/smallwebwaf/internal/remotelog"
 	"sneak.berlin/go/smallwebwaf/internal/requestlog"
+	"sneak.berlin/go/smallwebwaf/internal/rules"
 	"sneak.berlin/go/smallwebwaf/internal/state"
 )
 
@@ -28,11 +28,6 @@ import (
 // runit and docker wait a little longer before they kill the process.
 const shutdownTimeout = 5 * time.Second
 
-// remoteLogStopTimeout is how long, as smallwebwaf stops, the log lines
-// still waiting are sent to SWWAF_LOG_REMOTE_URL before they are given
-// up. stdout has carried them.
-const remoteLogStopTimeout = 2 * time.Second
-
 // Params are what Run needs from the process.
 type Params struct {
 	// Version is the version of the binary, set when it is built.
@@ -62,9 +57,9 @@ func Main(version string) int {
 	})
 }
 
-// Run reads the settings and the state files, then serves requests until
-// ctx is done. It returns the process's exit status, 1 when smallwebwaf
-// cannot start.
+// Run reads the settings, the rule files and the state files, then serves
+// requests until ctx is done. It returns the process's exit status, 1
+// when smallwebwaf cannot start.
 func Run(ctx context.Context, params Params) int {
 	processLog := requestlog.NewProcessLogger(params.Stdout)
 
@@ -75,25 +70,15 @@ func Run(ctx context.Context, params Params) int {
 		return 1
 	}
 
-	// While SWWAF_LOG_REMOTE_URL is set, every line on stdout from here on
-	// is sent there too.
-	stdout := params.Stdout
+	ruleFiles, err := rules.Load(rules.Params{
+		Dir:        cfg.RulesDir,
+		Enabled:    cfg.RulesEnabled,
+		ProcessLog: processLog,
+	})
+	if err != nil {
+		processLog.Error("cannot use the rule files", "error", err.Error())
 
-	var remote *remotelog.Sender
-
-	if cfg.LogRemoteURL != nil {
-		remote = remotelog.New(remotelog.Params{
-			URL:      cfg.LogRemoteURL,
-			RootCAs:  cfg.LogRemoteTLSCAs,
-			Buffer:   cfg.LogRemoteBuffer,
-			Facility: cfg.LogRemoteFacility,
-			AppName:  cfg.LogRemoteAppName,
-		})
-		stdout = io.MultiWriter(params.Stdout, remote)
-		processLog = requestlog.NewProcessLogger(stdout)
-
-		stopSending := startSending(ctx, remote, processLog)
-		defer stopSending()
+		return 1
 	}
 
 	// The state files give times in UTC.
@@ -101,14 +86,12 @@ func Run(ctx context.Context, params Params) int {
 
 	server := proxy.New(proxy.Params{
 		Config:     cfg,
-		RequestLog: stdout,
+		RequestLog: params.Stdout,
 		ProcessLog: processLog,
 		GeoJSURL:   lookup.URL,
 		Now:        now,
+		Rules:      ruleFiles,
 	})
-	if remote != nil {
-		server.Metrics.AddRemoteLog(remote)
-	}
 
 	files, err := state.Load(state.Params{
 		Dir:             cfg.StateDir,
@@ -140,41 +123,16 @@ func Run(ctx context.Context, params Params) int {
 		"address", listener.Addr().String(),
 		"settings", cfg)
 
-	return serve(ctx, server.Server, listener, files, processLog)
-}
-
-// startSending runs remote until the function it returns is called, which
-// then waits at most remoteLogStopTimeout for the lines still waiting to
-// be sent. Sending goes on after ctx is done, so that the lines written
-// while smallwebwaf stops are sent too.
-func startSending(
-	ctx context.Context, remote *remotelog.Sender, processLog *slog.Logger,
-) func() {
-	sending, stop := context.WithCancel(context.WithoutCancel(ctx))
-	sent := make(chan struct{})
-
-	go func() {
-		remote.Run(sending, processLog)
-		close(sent)
-	}()
-
-	return func() {
-		stop()
-
-		select {
-		case <-sent:
-		case <-time.After(remoteLogStopTimeout):
-		}
-	}
+	return serve(ctx, server.Server, listener, files, ruleFiles, processLog)
 }
 
 // serve serves requests on listener, writes the state files as they are
-// due, and takes in an admin's edits of them, until ctx is done. Then it
-// gives the requests in progress shutdownTimeout to finish, and writes
-// every state file.
+// due, takes in an admin's edits of them, and reads the rule files again
+// as they change, until ctx is done. Then it gives the requests in
+// progress shutdownTimeout to finish, and writes every state file.
 func serve(
 	ctx context.Context, server *http.Server, listener net.Listener,
-	files *state.Files, processLog *slog.Logger,
+	files *state.Files, ruleFiles *rules.Files, processLog *slog.Logger,
 ) int {
 	served := make(chan error, 1)
 
@@ -187,6 +145,7 @@ func serve(
 
 	written := make(chan struct{})
 	watched := make(chan struct{})
+	rulesWatched := make(chan struct{})
 
 	go func() {
 		files.Run(writing)
@@ -198,6 +157,11 @@ func serve(
 		close(watched)
 	}()
 
+	go func() {
+		ruleFiles.Watch(writing)
+		close(rulesWatched)
+	}()
+
 	select {
 	case err := <-served:
 		processLog.Error("serving failed", "error", err.Error())
@@ -236,6 +200,7 @@ func serve(
 	// missing from clients.json.
 	<-written
 	<-watched
+	<-rulesWatched
 
 	err = files.WriteAll()
 	if err != nil {

internal/smallwebwaf/smallwebwaf_test.go

@@ -10,8 +10,6 @@ import (
 	"net/http/httptest"
 	"os"
 	"path/filepath"
-	"slices"
-	"strconv"
 	"strings"
 	"sync"
 	"testing"
@@ -36,6 +34,7 @@ const (
 	stateWriteDelay      = "SWWAF_STATE_WRITE_DELAY"
 	stateCounterInterval = "SWWAF_STATE_COUNTER_INTERVAL"
 	rateLimitPerDay      = "SWWAF_RATE_LIMIT_PER_DAY"
+	rulesDir             = "SWWAF_RULES_DIR"
 	// greeting is what the tests' app answers.
 	greeting = "hello from the app"
 )
@@ -165,6 +164,7 @@ func TestAddressInUseStopsTheStart(t *testing.T) {
 	status := run(t.Context(), map[string]string{
 		listenAddr: taken.Addr().String(),
 		stateDir:   t.TempDir(),
+		rulesDir:   t.TempDir(),
 	}, out)
 	if status != 1 {
 		t.Errorf("exit status %d, want 1", status)
@@ -188,9 +188,15 @@ func TestServesUntilToldToStop(t *testing.T) {
 			listenAddr:  localhost + ":0",
 			upstreamURL: appURL,
 			stateDir:    dir,
+			rulesDir:    filepath.Join("..", "..", "share", "rules.d"),
 		}, out)
 	}()
 
+	// The default rule file is read.
+	if rules := out.line(t, "msg", "read the rule files")["rules"]; rules != 12.0 {
+		t.Errorf("read %v rules from the default rule file, want 12", rules)
+	}
+
 	starting := out.line(t, "msg", "starting")
 	wantStartingLine(t, starting, appURL, dir)
 
@@ -219,6 +225,7 @@ func TestStateKeptAcrossRestarts(t *testing.T) {
 		listenAddr:      localhost + ":0",
 		upstreamURL:     startApp(t),
 		stateDir:        t.TempDir(),
+		rulesDir:        t.TempDir(),
 		rateLimitPerDay: "2",
 		// Neither comes due in the test: the files are written as
 		// smallwebwaf stops.
@@ -255,6 +262,7 @@ func TestBanRefusesItsNetblockAfterARestartWithAnotherScope(t *testing.T) {
 		listenAddr:      localhost + ":0",
 		upstreamURL:     startApp(t),
 		stateDir:        t.TempDir(),
+		rulesDir:        t.TempDir(),
 		trustedProxies:  localhost + "/32",
 		rateLimitPerDay: "1",
 		scope:           "24",
@@ -302,6 +310,7 @@ func TestBanAddedAndLiftedByEditingBansJSON(t *testing.T) {
 		listenAddr:     localhost + ":0",
 		upstreamURL:    startApp(t),
 		stateDir:       dir,
+		rulesDir:       t.TempDir(),
 		trustedProxies: localhost + "/32",
 		// No write comes due in the test, so only the watch on the
 		// directory can take the edits in.
@@ -318,108 +327,49 @@ func TestBanAddedAndLiftedByEditingBansJSON(t *testing.T) {
 	})
 }
 
-func TestEveryLineIsAlsoSentToTheRemoteLogEndpoint(t *testing.T) {
+func TestRuleFileAddedWhileRunningTakesEffect(t *testing.T) {
 	t.Parallel()
 
-	endpoint, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", localhost+":0")
-	if err != nil {
-		t.Fatalf("listen: %v", err)
-	}
-
-	defer func() {
-		_ = endpoint.Close()
-	}()
-
+	dir := t.TempDir()
 	env := map[string]string{
-		listenAddr:             localhost + ":0",
-		upstreamURL:            startApp(t),
-		stateDir:               t.TempDir(),
-		"SWWAF_LOG_REMOTE_URL": "syslog+tcp://" + endpoint.Addr().String(),
+		listenAddr:  localhost + ":0",
+		upstreamURL: startApp(t),
+		stateDir:    t.TempDir(),
+		rulesDir:    dir,
+		// The requests sent until the rule takes effect must not break a
+		// rate limit, whose ban would refuse them too.
+		"SWWAF_RATE_LIMIT_PER_MINUTE": "off",
 	}
 
 	out := runUntilStopped(t, env, func(url string) {
 		wantGreeting(t, url)
+		saveUntilAnswered(t, filepath.Join(dir, "50-app.rules"),
+			"everything path block ^/\n", url, "203.0.113.9", http.StatusForbidden)
 	})
-	out.line(t, "type", "request")
-
-	// smallwebwaf connected as it started, and closes the connection once
-	// it has sent the lines written as it stopped.
-	conn, err := endpoint.Accept()
-	if err != nil {
-		t.Fatalf("accept: %v", err)
-	}
-
-	received, err := io.ReadAll(conn)
-	_ = conn.Close()
-
-	if err != nil {
-		t.Fatalf("read: %v", err)
-	}
-
-	// Lines written at once by several goroutines may reach stdout and
-	// the endpoint in different orders.
-	sent := messages(t, string(received))
-	written := slices.Collect(strings.Lines(out.text()))
-
-	slices.Sort(sent)
-	slices.Sort(written)
-
-	if !slices.Equal(sent, written) {
-		t.Errorf("sent\n%v\nwrote\n%v", sent, written)
-	}
+	out.line(t, "action", "rule_blocked")
 }
 
-func TestStalledRemoteLogEndpointHoldsUpNoRequest(t *testing.T) {
+func TestRuleFileThatDoesNotParseStopsTheStart(t *testing.T) {
 	t.Parallel()
 
-	const token = "0123456789abcdef0123456789abcdef"
+	dir := t.TempDir()
+	path := filepath.Join(dir, "00-default.rules")
 
-	// The endpoint takes connections and never answers, so the TLS
-	// handshake of each waits on it, and no line is ever sent.
-	endpoint, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", localhost+":0")
+	err := os.WriteFile(path, []byte("# probes\nenv-file path bann ^/\\.env$\n"), 0o600)
 	if err != nil {
-		t.Fatalf("listen: %v", err)
+		t.Fatalf("write the rule file: %v", err)
 	}
 
-	defer func() {
-		_ = endpoint.Close()
-	}()
+	wantRulesRefused(t, dir, path+`, line 2: the action "bann" is not log, block or ban`)
+}
 
-	env := map[string]string{
-		listenAddr:                localhost + ":0",
-		upstreamURL:               startApp(t),
-		stateDir:                  t.TempDir(),
-		"SWWAF_LOG_REMOTE_URL":    "syslog+tls://" + endpoint.Addr().String(),
-		"SWWAF_LOG_REMOTE_BUFFER": "1",
-		"SWWAF_METRICS_TOKEN":     token,
-	}
+func TestRulesDirThatDoesNotExistStopsTheStart(t *testing.T) {
+	t.Parallel()
 
-	out := runUntilStopped(t, env, func(url string) {
-		wantGreeting(t, url)
+	dir := filepath.Join(t.TempDir(), "rules.d")
 
-		// More than one line has been written, and the buffer holds the
-		// last.
-		metrics := metricsText(t, url+"_smallwebwaf/metrics", token)
-		for _, series := range []string{
-			"smallwebwaf_remote_log_lines_sent_total 0",
-			"smallwebwaf_remote_log_buffer_depth 1",
-		} {
-			if !strings.Contains(metrics, "\n"+series+"\n") {
-				t.Errorf("no %q in the metrics:\n%s", series, metrics)
-			}
-		}
-
-		if strings.Contains(metrics, "\nsmallwebwaf_remote_log_lines_dropped_total 0\n") ||
-			!strings.Contains(metrics, "\nsmallwebwaf_remote_log_lines_dropped_total ") {
-			t.Errorf("no line dropped in the metrics:\n%s", metrics)
-		}
-
-		// Closed, the endpoint refuses the connection made to send the
-		// lines still waiting at the stop, which then does not wait.
-		_ = endpoint.Close()
-	})
-
-	out.line(t, "type", "request")
+	wantRulesRefused(t, dir, "SWWAF_RULES_DIR cannot be read: open "+dir+
+		": no such file or directory")
 }
 
 func TestStateFileThatDoesNotParseStopsTheStart(t *testing.T) {
@@ -455,7 +405,9 @@ func wantStartRefused(t *testing.T, dir, want string) {
 
 	out := &output{}
 
-	status := run(ctx, map[string]string{listenAddr: localhost + ":0", stateDir: dir}, out)
+	status := run(ctx, map[string]string{
+		listenAddr: localhost + ":0", stateDir: dir, rulesDir: t.TempDir(),
+	}, out)
 	if status != 1 {
 		t.Fatalf("exit status %d, want 1", status)
 	}
@@ -468,6 +420,30 @@ func wantStartRefused(t *testing.T, dir, want string) {
 	}
 }
 
+// wantRulesRefused runs smallwebwaf with its rule files in dir, and
+// checks that it stops at start, with the error want. If it starts
+// instead, it is stopped after waitLimit.
+func wantRulesRefused(t *testing.T, dir, want string) {
+	t.Helper()
+
+	ctx, stop := context.WithTimeout(t.Context(), waitLimit)
+	defer stop()
+
+	out := &output{}
+
+	status := run(ctx, map[string]string{
+		listenAddr: localhost + ":0", stateDir: t.TempDir(), rulesDir: dir,
+	}, out)
+	if status != 1 {
+		t.Fatalf("exit status %d, want 1", status)
+	}
+
+	line := out.line(t, "msg", "cannot use the rule files")
+	if line["error"] != want || line["level"] != "ERROR" {
+		t.Errorf("start refused with %v, want the error %q", line, want)
+	}
+}
+
 // startApp starts an app that answers every request with greeting, and
 // returns its URL.
 func startApp(t *testing.T) string {
@@ -548,8 +524,10 @@ func wantStartingLine(t *testing.T, line map[string]any, appURL, dir string) {
 		"SWWAF_LIMIT_BAN_DURATION":              "1h",
 		"SWWAF_LIMIT_BAN_REPEAT_WINDOW":         "24h",
 		"SWWAF_MAX_BAN_DURATION":                "7d",
+		"SWWAF_ATTACK_BAN_DURATION":             "7d",
 		"SWWAF_MAX_BANS":                        "5000",
 		"SWWAF_BAN_SCOPE_V4_PREFIX":             "32",
+		"SWWAF_RULES_ENABLED":                   "true",
 	}
 
 	for name, value := range want {
@@ -589,69 +567,6 @@ func wantGreeting(t *testing.T, url string) {
 	}
 }
 
-// messages returns the message of each record in received, octet-counted
-// frames of RFC 5424 records with the default facility and app name, each
-// with the newline that ends a line on stdout.
-func messages(t *testing.T, received string) []string {
-	t.Helper()
-
-	hostname, _ := os.Hostname()
-	header := " " + hostname + " " + hostname + " - - - "
-
-	var found []string
-
-	for received != "" {
-		count, rest, _ := strings.Cut(received, " ")
-
-		length, err := strconv.Atoi(count)
-		if err != nil || length > len(rest) {
-			t.Fatalf("no frame at %q", received)
-		}
-
-		record := rest[:length]
-		received = rest[length:]
-
-		_, message, ok := strings.Cut(record, header)
-		if !ok || !strings.HasPrefix(record, "<134>1 ") {
-			t.Fatalf("record %q, want priority <134> and header %q", record, header)
-		}
-
-		found = append(found, message+"\n")
-	}
-
-	return found
-}
-
-// metricsText asks for the metrics at url with token, and returns them.
-func metricsText(t *testing.T, url, token string) string {
-	t.Helper()
-
-	req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, url,
-		http.NoBody)
-	if err != nil {
-		t.Fatalf("new request: %v", err)
-	}
-
-	req.Header.Set("Authorization", "Bearer "+token)
-
-	transport := &http.Transport{}
-	defer transport.CloseIdleConnections()
-
-	res, err := (&http.Client{Transport: transport}).Do(req)
-	if err != nil {
-		t.Fatalf("request: %v", err)
-	}
-
-	body, err := io.ReadAll(res.Body)
-	_ = res.Body.Close()
-
-	if err != nil || res.StatusCode != http.StatusOK {
-		t.Fatalf("metrics answered %d (%v)", res.StatusCode, err)
-	}
-
-	return string(body)
-}
-
 // wantRefused checks that a request to url is refused with 403, the
 // default SWWAF_BAN_RESPONSE.
 func wantRefused(t *testing.T, url string) {

internal/state/state.go

@@ -48,6 +48,7 @@ var (
 	errVersion = errors.New("unknown version")
 	// errMissing is for an entry without a field it needs.
 	errMissing = errors.New("has no")
+	errCause   = errors.New("is not limit or attack")
 )
 
 // Params are what Load needs.
@@ -95,11 +96,12 @@ type bansFile struct {
 }
 
 // banEntry is a ban as bans.json holds it: a permanent ban's expires is
-// null.
+// null, and a ban an admin added may have no cause.
 type banEntry struct {
 	Netblock netip.Prefix `json:"netblock"`
 	Start    time.Time    `json:"start"`
 	Expires  *time.Time   `json:"expires"`
+	Cause    string       `json:"cause,omitempty"`
 	Notes    bans.Notes   `json:"notes"`
 }
 
@@ -444,7 +446,9 @@ func (f *Files) encode(name string) ([]byte, error) {
 
 // newBanEntry returns ban as bans.json holds it.
 func newBanEntry(ban bans.Ban) banEntry {
-	entry := banEntry{Netblock: ban.Netblock, Start: ban.Start, Notes: ban.Notes}
+	entry := banEntry{
+		Netblock: ban.Netblock, Start: ban.Start, Cause: ban.Cause, Notes: ban.Notes,
+	}
 	if !ban.Permanent() {
 		entry.Expires = &ban.Expires
 	}
@@ -454,7 +458,7 @@ func newBanEntry(ban bans.Ban) banEntry {
 
 // ban returns the ban an entry of bans.json holds.
 func (e banEntry) ban() bans.Ban {
-	ban := bans.Ban{Netblock: e.Netblock, Start: e.Start, Notes: e.Notes}
+	ban := bans.Ban{Netblock: e.Netblock, Start: e.Start, Cause: e.Cause, Notes: e.Notes}
 	if e.Expires != nil {
 		ban.Expires = *e.Expires
 	}
@@ -466,7 +470,8 @@ func (e banEntry) ban() bans.Ban {
 // client, a start, from which the length of the netblock's next ban is
 // worked out, or an expires, which would make it permanent. A permanent
 // ban's expires is null, which Bans cannot tell from a missing one, so
-// each expires is read again as written.
+// each expires is read again as written. A cause other than limit or
+// attack, most likely misspelt, is refused too.
 func (f *bansFile) check(data []byte) error {
 	var written struct {
 		Bans []struct {
@@ -487,6 +492,9 @@ func (f *bansFile) check(data []byte) error {
 			return missing(i, "start")
 		case written.Bans[i].Expires == nil:
 			return missing(i, "expires")
+		case entry.Cause != "" && entry.Cause != bans.CauseLimit &&
+			entry.Cause != bans.CauseAttack:
+			return fmt.Errorf("entry %d's cause %q %w", i+1, entry.Cause, errCause)
 		}
 	}
 

internal/state/state_test.go

@@ -63,7 +63,11 @@ const permanentBansJSON = `{
                 },
                 "requests": 1500,
                 "refused": 3,
-                "earlier_bans": 5
+                "earlier_bans": {
+                    "limit": 3,
+                    "attack": 1,
+                    "without_cause": 1
+                }
             }
         }
     ]
@@ -263,6 +267,17 @@ func TestEntryWithoutAFieldItNeedsStopsTheStart(t *testing.T) {
 	}
 }
 
+func TestBanWithACauseSmallwebwafDoesNotGiveStopsTheStart(t *testing.T) {
+	t.Parallel()
+
+	wantRefused(t, bansJSON, `{"version": 1, "bans": [`+
+		`{"netblock": "203.0.113.9/32", "start": "2026-10-06T00:00:00Z", `+
+		`"expires": null, "cause": "attack"}, `+
+		`{"netblock": "203.0.113.10/32", "start": "2026-10-06T00:00:00Z", `+
+		`"expires": null, "cause": "atack"}]}`,
+		`: entry 2's cause "atack" is not limit or attack`)
+}
+
 func TestUnknownVersionStopsTheStart(t *testing.T) {
 	t.Parallel()
 
@@ -881,6 +896,7 @@ func newParams(dir string) state.Params {
 			LimitBanDuration:     time.Hour,
 			LimitBanRepeatWindow: 24 * time.Hour,
 			MaxBanDuration:       7 * 24 * time.Hour,
+			AttackBanDuration:    7 * 24 * time.Hour,
 			MaxBans:              5000,
 		}),
 		Limiter: ratelimit.New(ratelimit.Limits{}),
@@ -893,14 +909,17 @@ func newParams(dir string) state.Params {
 	}
 }
 
-// fill puts a ban that ends and one that does not, clients with counts
-// and histories, and GeoJS answers into the parts of params.
+// fill puts a permanent ban without a cause, as an admin adds one, a ban
+// for a broken limit and one for a clear sign of attack, clients with
+// counts and histories, and GeoJS answers into the parts of params.
 func fill(params state.Params) {
 	now := midnight()
 	client := netip.MustParsePrefix("203.0.113.9/32")
 
 	params.Ledger.Load([]bans.Ban{permanentBan()})
 	params.Ledger.BanForLimit(client, now, bans.Notes{Country: "DE", Limit: 1})
+	params.Ledger.BanForAttack(netip.MustParsePrefix("192.0.2.1/32"), now,
+		bans.Notes{RuleID: "env-file", Target: "path"})
 
 	for _, c := range []string{"2001:db8::/64", "203.0.113.9/32", "192.0.2.1/32"} {
 		params.Limiter.Count(netip.MustParsePrefix(c), now)
@@ -939,7 +958,7 @@ func permanentBan() bans.Ban {
 			},
 			Requests:    1500,
 			Refused:     3,
-			EarlierBans: 5,
+			EarlierBans: bans.EarlierBans{Limit: 3, Attack: 1, WithoutCause: 1},
 		},
 	}
 }

script/example-app

@@ -3,9 +3,10 @@
 # deploy/example-app, then run the app's container with a volume for the
 # state files and check that the health check passes, that a request is
 # served through smallwebwaf, that a second one in a minute bans the
-# client, that `sv stop` stops smallwebwaf in order, that `docker stop`
-# stops the container without having to kill it, and that a new
-# container on the same volume still refuses the banned client. The
+# client, that a probe for /.env bans another client, which its next
+# request bans for good, that `sv stop` stops smallwebwaf in order, that
+# `docker stop` stops the container without having to kill it, and that
+# a new container on the same volume still refuses the banned client. The
 # containers, the volume and both images are removed however the script
 # ends. Building the app needs network access, for nixpkgs' binary cache.
 # script/check does not run this.
@@ -77,6 +78,15 @@ refused() {
     [ "$code" = 403 ]
 }
 
+# refused_from <client> <path>: a request for path from client, as
+# X-Forwarded-For names it, gets 403. smallwebwaf believes the header
+# from docker's gateway, a private address.
+refused_from() {
+    code="$(curl --silent --output /dev/null --write-out '%{http_code}' \
+        --max-time 10 --header "X-Forwarded-For: $1" "http://$address$2")" || true
+    [ "$code" = 403 ]
+}
+
 main() {
     cd "$ROOT"
     trap cleanup EXIT
@@ -100,6 +110,14 @@ main() {
     wait_for "smallwebwaf logged no ban" logged '"action":"rate_limited"'
     echo "example-app: a second request in a minute bans the client"
 
+    refused_from 203.0.113.9 /.env || fail "a probe for /.env was not refused"
+    wait_for "smallwebwaf logged no ban for the probe" \
+        logged '"action":"banned","rule_ids":["env-file"]'
+    refused_from 203.0.113.9 / || fail "the client of the probe was let through"
+    wait_for "the client's next request did not make its ban permanent" \
+        logged '"ban_expires":"permanent"'
+    echo "example-app: a probe for /.env bans the client, its next request for good"
+
     docker exec "$CONTAINER" sv stop smallwebwaf >/dev/null ||
         fail "sv stop smallwebwaf failed"
     wait_for "smallwebwaf did not stop in order" logged '"msg":"stopped"'

script/run

@@ -1,7 +1,9 @@
 #!/bin/sh
 # script/run: build bin/smallwebwaf with script/build and run it, with
 # the settings in the environment. Unless SWWAF_STATE_DIR is set, the
-# state files go in bin/state, beside the binary.
+# state files go in bin/state, beside the binary, and unless
+# SWWAF_RULES_DIR is set, the rule files are those of share/rules.d,
+# which the image ships.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
@@ -14,6 +16,10 @@ main() {
         export SWWAF_STATE_DIR
         mkdir -p "$SWWAF_STATE_DIR"
     fi
+    if [ -z "${SWWAF_RULES_DIR+set}" ]; then
+        SWWAF_RULES_DIR="$ROOT/share/rules.d"
+        export SWWAF_RULES_DIR
+    fi
     exec "$ROOT/bin/smallwebwaf"
 }
 

share/rules.d/00-default.rules

@@ -0,0 +1,15 @@
+# 00-default.rules: probes no real visitor sends, anchored at the site root
+
+# id             target      action  regex
+env-file         path        ban     (?i)^/\.env(\.[a-z]+)?$
+vcs-dir          path        ban     (?i)^/\.(git|svn|hg|bzr)(/|$)
+secrets-dir      path        ban     (?i)^/\.(aws|ssh|docker|kube)/
+secret-file      path        ban     (?i)^/\.(htpasswd|htaccess|npmrc|netrc|pgpass|git-credentials|bash_history|DS_Store)$
+editor-dir       path        ban     (?i)^/\.(vscode|idea)/
+backup-file      path        ban     (?i)^/[^/]+\.(php(\.[a-z0-9]+|~)|sql(\.[a-z0-9]+)?)$
+log-file         path        ban     (?i)^/(debug|error|access)\.log$
+compose-file     path        ban     (?i)^/(docker-)?compose\.ya?ml$
+php-shell        path        ban     (?i)^/(shell|c99|r57|wso|alfa)\.php$
+scanner-agent    user_agent  ban     (?i)\b(sqlmap|nikto|nuclei|masscan|zgrab|wpscan)\b
+path-traversal   uri         block   (\.\./){2,}
+empty-agent      user_agent  log     ^$