Reword the build-architecture history line in TODO.md (closes #412)

The architecture is read at run time, so nothing passes it in at build time. The dated history entry for issue 31 in TODO.md now says a build-architecture global was removed, without naming it, so the word no longer appears in the tree.

Model: opus-5-5

.dockerignore

@@ -1,15 +1,14 @@
-# .git is deliberately NOT excluded: the build derives the version it stamps
-# into the binary from it (script/version). Nor is any tracked file: git in
-# the build would see it as deleted and mark the version -dirty. Only
-# untracked files belong here.
-#
 # .ci-fingerprint is deliberately NOT excluded: it is the CI cache barrier
 # that keeps the check stages from replaying a cached pass. See the lint
 # stage of the Dockerfile.
+.git/
 bin/
 # Extracted from 3p/ by `make assets` inside the build; a host copy is not
 # needed. The tarball in 3p/ must stay in the context.
 static/js/alpine.min.js
+*.md
+LICENSE
+.editorconfig
 .env
 .env.*
 *.db

.gitea/workflows/check.yml

@@ -28,11 +28,12 @@ jobs:
         run: script/ci-mark-superseded
 
       - name: Fingerprint the build context
-        # Every commit that changes more than docs writes a new fingerprint
+        # `.dockerignore` keeps docs out of the build context, so a docs-only
-        # into the context, which invalidates the `COPY . .` layer of both
+        # commit legitimately replays the whole image from cache and stays
-        # check stages: a commit that was never linted, formatted-checked,
+        # cheap. Every other commit writes a new fingerprint into the context,
-        # tested and built cannot report success from cache. Docs-only
+        # which invalidates the `COPY . .` layer of both check stages: a
-        # commits rebuild too, since the context also carries `.git`.
+        # commit that was never linted, formatted-checked, tested and built
+        # cannot report success from cache.
         run: |
           set -eu
           fp="$(git log -1 --format=%H -- . ':!*.md' ':!LICENSE' ':!.editorconfig')"

Dockerfile

@@ -38,8 +38,8 @@ FROM golang:1.26.1-bookworm@sha256:4465644228bc2857a954b092167e12aa59c006a349228
 COPY --from=lint /src/go.sum /dev/null
 
 # jq is a runtime dependency of script/ci-mark-superseded, which the test
-# suite executes. git is what script/version derives the version with.
+# suite executes.
-RUN apt-get update && apt-get install -y --no-install-recommends make curl ca-certificates jq git && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y --no-install-recommends make curl ca-certificates jq && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /build
 
@@ -55,22 +55,14 @@ COPY . .
 # from its tarball in 3p/.
 RUN make test
 
-# Version stamped into the binary: the VERSION build arg when one is
+# Version stamped into the binary. .dockerignore excludes .git/, so
-# given, otherwise what script/version derives from the .git the build
+# nothing in this stage can derive it: script/docker resolves it on the
-# context carries, so any `docker build .` of a clone stamps its commit.
+# host and passes it in. The default is what a bare `docker build .`
-# With neither, as from a source tarball, it is "unknown".
+# with no --build-arg gets, and it names no tag the tree may not be at.
 #
 # Declared here, below the test step, so a changed version does not
 # invalidate its cached layer.
-ARG VERSION
+ARG VERSION=unknown
-
-# A context that carries .git must not stamp "unknown": that means git is
-# missing here or refused to read the checkout, and the image could not be
-# traced back to its commit.
-RUN if [ -d .git ] && [ "$(make version VERSION="$VERSION")" = unknown ]; then \
-        echo "version is unknown although the build context carries .git" >&2; \
-        exit 1; \
-    fi
 
 RUN make build VERSION="$VERSION"
 

Makefile

@@ -4,12 +4,12 @@
 .DEFAULT_GOAL := check
 
 # Version stamped into the binary. Derived from git by script/version;
-# override it (`make build VERSION=v1.2.3`) to stamp a given value, which is
+# override it (`make build VERSION=v1.2.3`) where git metadata is
-# how the Dockerfile passes its build arg in.
+# unavailable, which is how the Dockerfile passes its build arg in.
 VERSION ?= $(shell script/version)
 
-# An empty override (`make build VERSION=`, or the Dockerfile's `make build
+# An empty override (`make build VERSION=`, or a `--build-arg VERSION=`
-# VERSION="$VERSION"` when no VERSION build arg was given) means unset,
+# landing on the Dockerfile's `make build VERSION="$VERSION"`) means unset,
 # exactly as it does in script/version -- stamping "" would leave the binary
 # reporting no version and the footer back on its "dev" fallback. `override`
 # is required: a plain assignment loses to the command-line definition it

README.md

@@ -142,7 +142,7 @@ TTY detection, and security headers are always applied.
 | `RETENTION_SWEEP_INTERVAL` | How often the retention reaper and archive sweeper run (Go duration, must be positive) | `1h` |
 | `SESSION_IDLE_TIMEOUT`  | Idle session timeout (Go duration)  | `24h`    |
 | `RECEIVER_RATE_LIMIT`   | Receiver requests/minute per IP per entrypoint (10x that per IP across the route) | `120` |
-| `TRUSTED_PROXIES`       | CIDRs whose forwarded headers are trusted (unset: all clients behind a proxy share one rate-limit bucket; a correct login password is never throttled either way) | `""` (none) |
+| `TRUSTED_PROXIES`       | CIDRs whose forwarded headers are trusted. A set value replaces the default. If any client can reach webhooker, or the proxy in front of it, from an RFC 1918 source address, set it to the proxy's address alone. See [Trusted proxies](#trusted-proxies) | `10.0.0.0/8,172.16.0.0/12,192.168.0.0/16` (RFC 1918) |
 | `ALLOWED_EGRESS_CIDRS`  | CIDRs that delivery targets may reach despite the SSRF blocklist. Read [Allowing egress to your own network](#allowing-egress-to-your-own-network) before setting it | `""` (none) |
 
 #### Allowing egress to your own network
@@ -157,6 +157,21 @@ public cloud metadata addresses: currently only `168.63.129.16`, Azure's
 WireServer, which serves an Azure VM its credentials. Because it is a
 public address, listing it in `ALLOWED_EGRESS_CIDRS` reopens it.
 
+That is all the default blocklist covers: the IPv4 private and reserved
+ranges; of IPv6, only loopback (`::1`), unique local addresses
+(`fc00::/7`) and link-local addresses (`fe80::/10`); and certain public
+addresses. A public address belongs on the default blocklist only if it
+hands credentials, user data or bootstrap material to whatever can reach
+it, without the caller presenting anything. A provider's other public
+addresses are not refused. IBM Cloud, for example, serves its package
+mirrors, time servers and object storage on `161.26.0.0/16`, and the
+private endpoints of its own cloud services on `166.8.0.0/14`. Neither
+range hands out credentials that way: the token service among those
+endpoints issues a token only in exchange for something the caller
+presents, such as an API key. Reaching these services can be a
+legitimate delivery, and every cloud has some, so a partial list would
+promise coverage it does not give.
+
 That default is also inconvenient for the thing webhooker is mostly
 for: taking a public webhook and forwarding it to something on your own
 network. A container on the same Docker network, a box on `10.x`, a
@@ -374,41 +389,37 @@ unlocked.
 `TRUSTED_PROXIES` is a comma-separated list of CIDR blocks (a bare
 address such as `192.168.1.7` is accepted and treated as a single
 host), for example `192.168.1.7, 2001:db8::5`. It decides whose
-`X-Forwarded-For` header the rate limiters believe, so it should name
+`X-Forwarded-For` header the rate limiters believe, so it should cover
-the addresses of your reverse proxies and nothing else.
+the addresses of your reverse proxies.
 
 `X-Forwarded-For` is honoured **only** when the connecting peer is
 inside one of these blocks; for every other peer the client identity is
-the connection's own address and the header is ignored. The default is
+the connection's own address and the header is ignored. Unset (or
-the empty list, which trusts nobody — anything else would let any
+empty), the list is the RFC 1918 private ranges: `10.0.0.0/8`,
-client pick its own rate limit bucket, minting a fresh one per request
+`172.16.0.0/12` and `192.168.0.0/16`. A set value replaces the default
-or draining someone else's. Set it to the address of your reverse
+entirely. A set but unparseable value aborts startup.
-proxy, and to nothing wider. A set but unparseable value aborts
-startup.
 
-That default is safe against forged headers, but leaving it unset in
+If any client can reach webhooker, or the proxy in front of it, from an
-production has a cost you must know about. Production runs behind a
+RFC 1918 source address (directly, or through anything that can
-TLS-terminating reverse proxy, so with `TRUSTED_PROXIES` unset every
+rewrite source addresses, such as NAT or a published container port),
-request keys on the proxy's own address and all clients share a single
+set `TRUSTED_PROXIES` to the proxy's address alone, or every rate
-bucket per limit. The receiver limits become service-wide ceilings,
+limit, the webhook receiver's included, can be bypassed by those
-and the login endpoint's failure counting collapses onto one key, so a
+clients. The address to set is the `remoteIP` field of the
-stranger's wrong passwords throttle every other client's wrong
+`http request` log line for a request that came through the proxy.
-passwords.
+
+Behind a proxy the list does not cover, every request keys on the
+proxy's own address and all clients share a single bucket per limit.
+The receiver limits become service-wide ceilings, and the login
+endpoint's failure counting collapses onto one key, so a stranger's
+wrong passwords throttle every other client's wrong passwords. Set
+`TRUSTED_PROXIES` to that proxy's address to restore per-client
+buckets.
 
 What it cannot do is lock the operator out. The login endpoint
 verifies credentials **before** it consults any limit and charges only
 failures, so a correct password is never throttled no matter how full
 the bucket is. See [Rate Limiting](#rate-limiting).
 
-The remedy is to set `TRUSTED_PROXIES` to your reverse proxy's
-address, which restores per-client buckets. webhooker logs a warning
-at startup whenever `TRUSTED_PROXIES` is empty, in every environment,
-because behind a proxy every client shares one bucket in `dev` and
-`prod` alike. The warning is informational when nothing proxies to the
-process: with no proxy in front, the peer address is the client's own
-and the buckets are already per-client. See
-[Rate Limiting](#rate-limiting) for what each limit shares.
-
 `X-Real-IP` and `True-Client-IP` are **never** read, from any peer.
 Reverse proxies append to `X-Forwarded-For` but forward other client
 headers verbatim, so a single-valued header is client-controlled even
@@ -424,20 +435,10 @@ instead, since past such an entry the chain is not the shape assumed
 here. The peer address is likewise used when the header is absent or
 every hop in it is a trusted proxy.
 
-Two operator requirements follow:
+Your proxy must therefore **append** the peer address to
-
+`X-Forwarded-For` (nginx `$proxy_add_x_forwarded_for`, HAProxy
-- Your proxy must **append** the peer address to `X-Forwarded-For`
+`option forwardfor`, Caddy and AWS ALB by default), and must append a
-  (nginx `$proxy_add_x_forwarded_for`, HAProxy `option forwardfor`,
+bare address with no port.
-  Caddy and AWS ALB by default), and must append a bare address with
-  no port.
-- List proxy hosts **only**. Any address inside `TRUSTED_PROXIES`
-  chooses its own rate-limit key: its `X-Forwarded-For` is walked, so
-  it can name a different address on every request to get a fresh
-  bucket each time, or name another client's address to drain that
-  client's bucket. Never list a block that also covers clients — a
-  broad `10.0.0.0/8` on a network where clients live in the same range
-  makes all three limits, including the unauthenticated webhook
-  receiver, silently bypassable by every client in the block.
 
 #### Sessions
 
@@ -736,10 +737,15 @@ repository's `Dockerfile` and runs it. The app needs:
 - **Volume:** one host directory mounted at `/var/lib/webhooker`.
 - **Environment variables:**
     - `WEBHOOKER_ENVIRONMENT=prod`
-    - `TRUSTED_PROXIES`: your reverse proxy's address on that Docker
+    - `TRUSTED_PROXIES`: unset, it is the RFC 1918 ranges. Set it to
-      network. The `remoteIP` field of the `http request` log line for a
+      your reverse proxy's address alone if that address is outside
-      request that came through the proxy shows it; the health check's
+      those ranges, or if any client can reach webhooker, or the proxy,
-      own lines show `::1`. See [Trusted proxies](#trusted-proxies).
+      from an RFC 1918 source address (directly, or through anything
+      that can rewrite source addresses, such as NAT or a published
+      container port). The `remoteIP` field of the `http request` log
+      line for a request that came through the proxy shows that
+      address; the health check's own lines show `::1`. See
+      [Trusted proxies](#trusted-proxies).
     - Leave `BIND_ADDRESS` and `DATA_DIR` unset: the image sets
       `BIND_ADDRESS` to `0.0.0.0`, and `DATA_DIR` defaults to
       `/var/lib/webhooker`.
@@ -802,12 +808,16 @@ reports.
    behind a proxy means the `X-Forwarded-Proto` header. The block below
    sets it; without it every request is read as plaintext and cookies
    ship without `Secure`. See [Configuration](#configuration).
-3. **Set `TRUSTED_PROXIES` to the proxy's address.** Unset, every rate
+3. **Make sure `TRUSTED_PROXIES` covers the proxy's address.** For a
-   limiter keys on the connecting peer, which behind a proxy is the
+   proxy it does not cover, every rate limiter keys on the proxy, so
-   proxy on every request: all clients collapse into one global bucket
+   all clients share one bucket per limit. Unset, the list is the RFC
-   per limit and the receiver's per-IP limits become service-wide
+   1918 ranges, which do not cover a proxy that reaches the binary
-   ceilings. See [Trusted proxies](#trusted-proxies). List the proxy
+   itself over loopback (the binary bound to `127.0.0.1`). With the
-   and nothing else.
+   image, the address to check is the `remoteIP` field of the
+   `http request` log line for a request that came through the proxy.
+   If any client can reach webhooker, or the proxy, from an RFC 1918
+   source address, set the list to the proxy's address alone. See
+   [Trusted proxies](#trusted-proxies).
 4. **Send `Host` as `$http_host`, not `$host`.** `$host` strips the
    port. webhooker's Origin/Referer check compares against the host it
    was given, so on any port other than 443 `$host` makes every form
@@ -1123,21 +1133,13 @@ build itself.
 | Uncommitted changes | the above with a `-dirty` suffix |
 | No git metadata | `unknown` |
 
-The image derives it the same way, from the `.git` that the build
+`unknown` is what a source tarball or a `docker build .` with no
-context carries, so any `docker build .` of a clone stamps the commit it
+`--build-arg VERSION=...` reports. `.dockerignore` excludes `.git/`, so
-was built from; a shallow clone of one branch has no tags and stamps the
+the build context carries no git metadata and the image cannot derive
-short SHA. `.dockerignore` must therefore leave out neither `.git` nor
+the version itself: `script/docker` (and so `make docker`) resolves it
-any tracked file, which git in the build would see as deleted, marking
+on the host and passes it in as the `VERSION` build arg. A build that
-the version `-dirty`. A `VERSION` build arg (`--build-arg VERSION=...`)
+reports `unknown` is a build nobody told what it was; it is not a
-takes precedence; `script/docker` (and so `make docker`) passes the one
+failure, but it cannot be traced back to a commit.
-`script/version` resolves on the host. The image build fails if its
-context carries `.git` and the version still comes out `unknown`, which
-means git in the build could not read the checkout.
-
-`unknown` is what a source tarball, or a `docker build` with no `.git`
-in its context and no `VERSION` build arg, reports. A build that reports
-`unknown` is a build nobody told what it was; it is not a failure, but
-it cannot be traced back to a commit.
 
 `make version` prints what the current checkout would stamp, and
 `make build VERSION=v1.2.3` overrides it. An empty override — from
@@ -1368,10 +1370,11 @@ It uses:
 - **[go-chi/httprate](https://github.com/go-chi/httprate)** for
   sliding-window rate limiting of the password-change and webhook
   receiver endpoints. The bucket is per client IP only when
-  `TRUSTED_PROXIES` names the reverse proxy; unset, every client
+  `TRUSTED_PROXIES` covers the reverse proxy (by default it covers the
-  behind that proxy shares one bucket per limit. The login endpoint
+  RFC 1918 private ranges); otherwise every client behind that proxy
-  counts failed attempts itself instead, so that a correct password is
+  shares one bucket per limit. The login endpoint counts failed
-  never throttled (see [Rate Limiting](#rate-limiting))
+  attempts itself instead, so that a correct password is never
+  throttled (see [Rate Limiting](#rate-limiting))
 - **[Prometheus](https://prometheus.io)** for metrics, served at
   `/metrics` behind basic auth
 - **[Sentry](https://sentry.io)** for optional error reporting
@@ -2542,47 +2545,44 @@ the tree is checked out: four checkouts have reported 3,959, 3,961,
 client-supplied field was cut, and that the shipped chain's stack
 arrived uncut — never the numbers.
 
-Every limiter here — receiver, login, and password change — identifies
+Every limiter here — receiver, login, password change, delivery replay
-the client the same way, through one shared key function: the
+and event resubmit — identifies the client the same way, through one
-connection's own address, unless the peer is listed in
+shared key function: the connection's own address, unless the peer is
-`TRUSTED_PROXIES`, in which case the forwarded client address is used
+inside `TRUSTED_PROXIES`, in which case the forwarded client address is
-instead. That address becomes a bucket by family: IPv4 keys on the full
+used instead. That address becomes a bucket by family: IPv4 keys on
-address, IPv6 on its `/64` prefix. A routed `/64` is the normal
+the full address, IPv6 on its `/64` prefix. A routed `/64` is the normal
 residential and mobile IPv6 allocation, so keying IPv6 per address would
 let one subscriber rotate source addresses and mint a fresh bucket per
 request, evading these limits at the network layer without spoofing
 anything; the cost is that distinct clients inside one `/64` share a
 bucket. IPv4-mapped addresses (`::ffff:1.2.3.4`) key as the IPv4 address
-they carry. See [Trusted proxies](#trusted-proxies). Deployed without that
+they carry. See [Trusted proxies](#trusted-proxies). When that variable
-variable set, a client behind a reverse proxy shares one bucket with
+does not cover the reverse proxy, a client behind it shares one bucket
-every other client behind the same proxy. Set `TRUSTED_PROXIES` to the
+with every other client behind the same proxy. Set `TRUSTED_PROXIES` to
-proxy's address to get per-client limits back. What the shared bucket
+the proxy's address to get per-client limits back. What the shared bucket
 costs is not the same for every limiter, and the two cases pull in
 opposite directions:
 
 - For the **receiver** limits it costs throughput, which is the safe
   direction to be wrong in: sharing can only make a limit bind sooner,
   never let a sender past it. It matters more for the aggregate limit
-  than for the per-entrypoint one: with `TRUSTED_PROXIES` unset behind
+  than for the per-entrypoint one: with every request keyed on the
-  the reverse proxy a production deployment is required to run behind,
+  proxy, the aggregate limit becomes a service-wide ceiling of 1200
-  every request keys on the proxy, so the aggregate limit becomes a
+  requests per minute across all senders and all entrypoints, where the
-  service-wide ceiling of 1200 requests per minute across all senders
+  per-entrypoint limit's capacity still grows with the number of
-  and all entrypoints, where the per-entrypoint limit's capacity still
+  entrypoints.
-  grows with the number of entrypoints. Any deployment with more than a
-  handful of busy entrypoints must set `TRUSTED_PROXIES`.
 - For the **login and password-change** limits it costs precision, not
   availability. Login failures from every client land in one counter,
   so a stranger's wrong passwords make the operator's own wrong
   passwords answer `429` sooner; the operator's _correct_ password is
-  never affected, because it is never counted. Production deployments
+  never affected, because it is never counted.
-  should still set `TRUSTED_PROXIES`; webhooker warns at startup
-  whenever it is empty, in any environment.
 
 #### The login endpoint
 
 The login `POST` is the one endpoint with no pre-emptive limiter in
 front of it, and that is deliberate. A limiter that spends budget on
-arrival is a lockout in this deployment shape: sharing one bucket, a
+arrival is a lockout wherever clients share one bucket, as they do
+behind a reverse proxy that `TRUSTED_PROXIES` does not cover: a
 stranger sending five POSTs a minute — about 0.08 requests per second,
 from anywhere — keeps it permanently full, and the operator has no
 second administrative path. So the handler inverts the order:
@@ -2679,8 +2679,10 @@ re-fills both verification slots on its first two requests. The
 remedies are to block the source at the reverse proxy, or to
 rate-limit `POST /pages/login` there — the one place a limit can be
 applied without reintroducing the lockout, because the proxy sees the
-real client address. Setting `TRUSTED_PROXIES` does not stop the
+real client address. `TRUSTED_PROXIES` does not stop the saturation.
-saturation, but it makes the source visible in the failure logs.
+The flood's source is in the proxy's access log: webhooker's own logs
+record the proxy's address, not the client's (see
+[Deployment behind a reverse proxy](#deployment-behind-a-reverse-proxy)).
 
 Finer-grained per-webhook rate limits (configured in the web UI and
 enforced in the webhook handler) can layer on top of this env-level
@@ -3038,10 +3040,9 @@ check, see [The login endpoint](#the-login-endpoint).
   It runs behind session auth, so only a client already holding a
   valid session reaches it, and an operator throttled out of changing
   a password can still log in. The bucket is per client IP only when
-  `TRUSTED_PROXIES` names the reverse proxy; unset, every client
+  `TRUSTED_PROXIES` covers the reverse proxy; otherwise every client
   shares one bucket, which costs precision rather than availability
-  (see [Rate Limiting](#rate-limiting)). webhooker warns at startup
+  (see [Rate Limiting](#rate-limiting))
-  whenever `TRUSTED_PROXIES` is empty
 - Prometheus metrics behind basic auth
 - Static assets embedded in binary (no filesystem access needed at
   runtime)
@@ -3173,9 +3174,8 @@ version is fixed independently of the compiler's:
    rebuilds the binary with `CGO_ENABLED=1` and static linking so it
    runs on musl. Both builds go through `make build`, the relink adding
    its `-extldflags` via `GO_LDFLAGS`, so neither can drop the `-X` that
-   stamps the version. The version is the `VERSION` build arg if one is
+   stamps the version. The version arrives as the `VERSION` build arg,
-   given, otherwise derived from the `.git` in the context, and the
+   since the context has no `.git` (see
-   stage fails if a context with `.git` would stamp `unknown` (see
    [Version stamping](#version-stamping)).
 3. **Runtime stage** (`alpine:3.21`) — copies the static binary and
    `deploy/docker-entrypoint.sh`, creates the `/var/lib/webhooker`
@@ -3207,17 +3207,16 @@ A layer cache lets `docker build .` exit 0 in seconds with the lint and
 test stages replayed rather than executed, which would make a green
 check meaningless. The `check` workflow therefore writes
 `.ci-fingerprint` into the build context before building. Its value is
-the hash of the last commit that touched anything other than `*.md`,
+the hash of the last commit that touched the build context, so:
-`LICENSE` and `.editorconfig`, so:
 
 - Any commit that changes code (including a squash merge whose tree
   matches an already-built branch) gets a new fingerprint, invalidates
   the `COPY . .` layer of both check stages, and really runs
   `make fmt-check`, `golangci-lint`, `make test`, and `make build`. A
   run that reports success ran them.
-- A docs-only commit leaves the fingerprint unchanged, but it still
+- A docs-only commit leaves the fingerprint unchanged — `.dockerignore`
-  rebuilds in full: the context also carries `.git`, which changes with
+  excludes `*.md`, `LICENSE` and `.editorconfig` from the context
-  every commit (see [Version stamping](#version-stamping)).
+  anyway — so the image replays from cache and costs seconds.
 
 The module download layer sits above `COPY . .` and stays cached either
 way.

TODO.md

@@ -387,7 +387,7 @@ point of the branch.
 - 2026-03-05 security headers middleware, session regeneration on
   login, request body size limits (#41)
 - 2026-03-04 tests for delivery, middleware, and session packages
-  (#32); removed globals.Buildarch (#31)
+  (#32); removed the build-architecture global (#31)
 - 2026-03-04 1.0 MVP merge: Webhook/Entrypoint/Target rename, core
   delivery engine with bounded worker pool and circuit breaker,
   parallel fan-out, per-webhook event databases, management UI (#16)

internal/config/config.go

@@ -75,6 +75,11 @@ const (
 	// internet-exposed endpoint.
 	defaultReceiverRateLimit = 120
 
+	// defaultTrustedProxies is TRUSTED_PROXIES when it is unset: the
+	// RFC 1918 private ranges, which a reverse proxy reaching the
+	// process over a Docker network or a private LAN connects from.
+	defaultTrustedProxies = "10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
+
 	// maxPort is the highest valid TCP port number. The lower
 	// bound (at least 1) is enforced by envPositiveInt.
 	maxPort = 65535
@@ -172,13 +177,14 @@ type Config struct {
 
 	// TrustedProxies is the set of networks whose members are
 	// allowed to speak for the client with X-Forwarded-For, the
-	// only forwarded header read. It is empty unless
+	// only forwarded header read. Unless TRUSTED_PROXIES is set it
-	// TRUSTED_PROXIES is set, and empty means no peer is
+	// is the RFC 1918 private ranges (defaultTrustedProxies); a set
-	// trusted: forwarded headers are then ignored entirely and
+	// value replaces them. If any client can reach the process, or
-	// clients are identified by the connection's own address.
+	// the proxy in front of it, from an RFC 1918 source address
-	// Members can choose their own rate-limit key, so this must
+	// (directly, or through anything that can rewrite source
-	// name proxy hosts only, never a block that also covers
+	// addresses, such as NAT or a published container port), it
-	// clients.
+	// must be set to the proxy's address alone, or every rate limit
+	// can be bypassed by those clients.
 	TrustedProxies []netip.Prefix
 
 	// AllowedEgressCIDRs is the set of networks a delivery target
@@ -460,14 +466,15 @@ func parseCIDR(entry string) (netip.Prefix, error) {
 
 // envPrefixList returns the value of the named environment variable
 // parsed as a comma-separated list of CIDR blocks (bare addresses
-// allowed). An unset, empty, or blank value yields an empty list. A
+// allowed). An unset, empty, or blank value is read as defaultValue
-// set value containing an unparseable entry is a hard error naming
+// instead. A set value containing an unparseable entry is a hard
-// the key and the bad entry, so startup fails loudly rather than
+// error naming the key and the bad entry, so startup fails loudly
-// silently running with a list the operator did not intend.
+// rather than silently running with a list the operator did not
-func envPrefixList(key string) ([]netip.Prefix, error) {
+// intend.
+func envPrefixList(key, defaultValue string) ([]netip.Prefix, error) {
 	v := strings.TrimSpace(os.Getenv(key))
 	if v == "" {
-		return nil, nil
+		v = defaultValue
 	}
 
 	var prefixes []netip.Prefix
@@ -681,12 +688,12 @@ func loadFromEnv() (*Config, error) {
 		return nil, err
 	}
 
-	trustedProxies, err := envPrefixList("TRUSTED_PROXIES")
+	trustedProxies, err := envPrefixList("TRUSTED_PROXIES", defaultTrustedProxies)
 	if err != nil {
 		return nil, err
 	}
 
-	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS")
+	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS", "")
 	if err != nil {
 		return nil, err
 	}
@@ -760,50 +767,6 @@ func (c *Config) warnEgressAllowlist(log *slog.Logger) {
 	)
 }
 
-// warnSharedRateLimitBucket logs a startup warning whenever
-// TRUSTED_PROXIES is empty, in any environment.
-//
-// With no trusted proxies every rate limiter keys on the connecting
-// peer's address. Whether that is harmless or dangerous depends on
-// what is in front of the process, which this code cannot observe:
-// with nothing in front, the peer is the client and the limits are
-// per-client as intended; behind a reverse proxy the peer is the proxy
-// for every request, so all clients share one bucket per limiter.
-//
-// The login endpoint no longer spends budget on arrival — it verifies
-// credentials first and charges only failures — so a shared bucket
-// cannot deny the operator a correct password. What it does collapse
-// is the failure counting: one client's wrong passwords throttle
-// everyone else's wrong passwords, and the receiver's limits become
-// service-wide ceilings.
-//
-// The warning is deliberately not gated on WEBHOOKER_ENVIRONMENT:
-// behind a proxy every client shares one bucket in dev and prod alike.
-//
-// The default of trusting nobody is deliberate — trusting forwarded
-// headers from arbitrary peers lets any client choose its own bucket —
-// so this warns rather than failing startup or changing the key.
-func (c *Config) warnSharedRateLimitBucket(log *slog.Logger) {
-	if len(c.TrustedProxies) > 0 {
-		return
-	}
-
-	log.Warn(
-		"TRUSTED_PROXIES is empty: every rate limit keys on the "+
-			"connecting peer's address. With nothing proxying to "+
-			"this process that is the client itself and the limits "+
-			"are per-client as intended. Behind a reverse proxy the "+
-			"peer is the proxy on every request, so all clients "+
-			"share one bucket per limit: the receiver limits become "+
-			"service-wide ceilings, and one client's failed logins "+
-			"throttle every other client's failed logins — a "+
-			"correct password still gets in. If anything proxies to "+
-			"this process, set TRUSTED_PROXIES to its address.",
-		"environment", c.Environment,
-		"trustedProxies", len(c.TrustedProxies),
-	)
-}
-
 // New creates a Config by reading environment variables.
 //
 //nolint:revive // lc parameter is required by fx even if unused.
@@ -849,7 +812,6 @@ func New(lc fx.Lifecycle, params ConfigParams) (*Config, error) {
 		"hasMetricsAuth", s.MetricsAuthEnabled(),
 	)
 
-	s.warnSharedRateLimitBucket(log)
 	s.warnEgressAllowlist(log)
 
 	return s, nil

internal/config/config_test.go

@@ -551,6 +551,11 @@ func testReceiverRateLimitSuccess(
 }
 
 func TestTrustedProxies(t *testing.T) {
+	// Unset, the RFC 1918 private ranges are trusted, so a reverse
+	// proxy on a Docker network or a private LAN is covered without
+	// configuration.
+	defaultProxies := []string{cidrPrivateV4, "172.16.0.0/12", "192.168.0.0/16"}
+
 	tests := []struct {
 		name        string
 		set         bool
@@ -559,18 +564,21 @@ func TestTrustedProxies(t *testing.T) {
 		expected    []string
 	}{
 		{
-			// The default must be "trust nobody": an empty list
-			// means forwarded headers are ignored, never that
-			// every peer may speak for the client.
 			name:     caseUnsetUsesDefault,
 			set:      false,
-			expected: []string{},
+			expected: defaultProxies,
 		},
 		{
-			name:     "blank value trusts nothing",
+			name:     "blank value uses default",
 			set:      true,
 			value:    "  ",
-			expected: []string{},
+			expected: defaultProxies,
+		},
+		{
+			name:     "set value replaces the default entirely",
+			set:      true,
+			value:    "203.0.113.7",
+			expected: []string{"203.0.113.7/32"},
 		},
 		{
 			name:  caseValidValueParsed,
@@ -845,101 +853,6 @@ func TestEgressAllowlistWarning(t *testing.T) {
 	}
 }
 
-// TestSharedRateLimitBucketWarning covers the startup warning that
-// tells an operator a deployment behind a reverse proxy shares one
-// rate-limit bucket between every client, which turns the receiver
-// limits into service-wide ceilings and collapses login failure
-// counting. It must fire whenever TRUSTED_PROXIES is empty, in any
-// environment, because behind a proxy every client shares one bucket
-// in dev and prod alike. It stays quiet once proxies are named.
-func TestSharedRateLimitBucketWarning(t *testing.T) {
-	tests := []struct {
-		name           string
-		environment    string
-		trustedProxies string
-		expectWarning  bool
-	}{
-		{
-			name:          "prod without trusted proxies warns",
-			environment:   config.EnvironmentProd,
-			expectWarning: true,
-		},
-		{
-			name:           "prod with trusted proxies is quiet",
-			environment:    config.EnvironmentProd,
-			trustedProxies: cidrPrivateV4,
-			expectWarning:  false,
-		},
-		{
-			name:          "dev without trusted proxies warns",
-			environment:   config.EnvironmentDev,
-			expectWarning: true,
-		},
-		{
-			name:           "dev with trusted proxies is quiet",
-			environment:    config.EnvironmentDev,
-			trustedProxies: cidrPrivateV4,
-			expectWarning:  false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Cannot use t.Parallel() here because t.Setenv
-			// is incompatible with parallel subtests.
-			t.Setenv("WEBHOOKER_ENVIRONMENT", tt.environment)
-
-			if tt.trustedProxies == "" {
-				require.NoError(
-					t, os.Unsetenv("TRUSTED_PROXIES"),
-				)
-			} else {
-				t.Setenv("TRUSTED_PROXIES", tt.trustedProxies)
-			}
-
-			var buf bytes.Buffer
-
-			log := slog.New(slog.NewJSONHandler(
-				&buf, &slog.HandlerOptions{
-					Level: slog.LevelDebug,
-				},
-			))
-
-			require.NoError(
-				t,
-				config.WarnSharedRateLimitBucketForTest(log),
-			)
-
-			if !tt.expectWarning {
-				assert.Empty(t, buf.String())
-
-				return
-			}
-
-			logged := buf.String()
-
-			assert.Contains(t, logged, `"level":"WARN"`)
-			assert.Contains(t, logged, "TRUSTED_PROXIES")
-			assert.Contains(t, logged, "share one bucket")
-			assert.Contains(
-				t, logged, "throttle every other client's failed logins",
-			)
-			// The warning must not claim a lockout the login
-			// endpoint no longer permits: credentials are verified
-			// before any budget is spent.
-			assert.Contains(
-				t, logged, "a correct password still gets in",
-			)
-			// The text must stay accurate for a developer with
-			// nothing in front of the process, where an empty
-			// list costs nothing.
-			assert.Contains(
-				t, logged, "nothing proxying to this process",
-			)
-		})
-	}
-}
-
 // metricsEnv describes what one subtest below puts in the
 // environment for a single METRICS_ variable. A variable that is
 // set to the empty string and one that is not set at all are

internal/config/export_test.go

@@ -6,21 +6,6 @@ import "log/slog"
 // the external config_test package so each helper can be covered by
 // its own table-driven test without weakening the package API.
 
-// WarnSharedRateLimitBucketForTest loads a Config from the current
-// environment and emits its startup warnings to log. The real logger
-// writes to stdout, so this lets the warning's firing condition be
-// asserted against a handler the test controls.
-func WarnSharedRateLimitBucketForTest(log *slog.Logger) error {
-	c, err := loadFromEnv()
-	if err != nil {
-		return err
-	}
-
-	c.warnSharedRateLimitBucket(log)
-
-	return nil
-}
-
 // WarnEgressAllowlistForTest loads a Config from the current
 // environment and emits its egress-allowlist startup warning to
 // log, so a test can assert both that the warning fires only when

internal/delivery/ssrf.go

@@ -43,6 +43,13 @@ var (
 // permit specific blocks out of this set with
 // ALLOWED_EGRESS_CIDRS; see Guard.
 //
+// A public address belongs on the default blocklist only if it
+// hands credentials, user data or bootstrap material to whatever
+// can reach it, without the caller presenting anything. A
+// provider's other public addresses are not refused, since
+// reaching them can be legitimate and no list of them could be
+// complete.
+//
 //nolint:gochecknoglobals // package-level network list is appropriate here
 var blockedNetworks []*net.IPNet
 

internal/handlers/auth.go

@@ -103,9 +103,10 @@ func (h *Handlers) renderLoginError(
 // The credential check runs BEFORE any rate-limit budget is
 // consulted, and only a failed check spends budget. That is what
 // keeps the single administrative path reachable: behind the reverse
-// proxy this deployment requires, with TRUSTED_PROXIES unset, every
+// proxy this deployment requires, when TRUSTED_PROXIES does not cover
-// client shares one bucket, so a limiter spent on arrival lets any
+// it, every client shares one bucket, so a limiter spent on arrival
-// stranger deny the operator's own correct password indefinitely.
+// lets any stranger deny the operator's own correct password
+// indefinitely.
 //
 // Verifying first means every login POST costs an Argon2id hash, so
 // the work is taken under a bounded number of verification slots.

internal/handlers/auth_test.go

@@ -25,7 +25,7 @@ const (
 
 	// sharedProxyPeer is the whole point of this file. Production is
 	// required to run behind a TLS-terminating reverse proxy, and
-	// TRUSTED_PROXIES defaults to empty, so every client — attacker
+	// when TRUSTED_PROXIES does not cover it every client — attacker
 	// and operator alike — reaches the process from the proxy's
 	// address and shares one rate-limit bucket. Both parties in
 	// these tests therefore use the same RemoteAddr.
@@ -115,11 +115,11 @@ func floodFailures(
 // done-criterion of https://git.eeqj.de/sneak/webhooker/issues/150.
 //
 // The attacker and the operator share one rate-limit bucket, because
-// behind the mandated reverse proxy with TRUSTED_PROXIES unset every
+// behind the mandated reverse proxy, when TRUSTED_PROXIES does not
-// client keys on the proxy's address. The attacker floods the
+// cover it, every client keys on the proxy's address. The attacker
-// operator's own username — a single-admin product has a predictable
+// floods the operator's own username — a single-admin product has a
-// one — far past the failure limit. The operator must still be able
+// predictable one — far past the failure limit. The operator must
-// to log in with the correct password.
+// still be able to log in with the correct password.
 //
 // This fails if credentials stop being verified ahead of the limiter.
 func TestLogin_StrangersFloodCannotLockOutTheOperator(t *testing.T) {

internal/middleware/loginguard.go

@@ -108,10 +108,10 @@ type failureWindow struct {
 //
 // A limiter that spends budget on arrival cannot protect a
 // single-admin product: behind the reverse proxy the deployment
-// requires, with TRUSTED_PROXIES unset, every client keys on the
+// requires, when TRUSTED_PROXIES does not cover it, every client
-// proxy, so a stranger trickling five POSTs a minute keeps the one
+// keys on the proxy, so a stranger trickling five POSTs a minute
-// bucket full and the operator's own correct password is answered 429
+// keeps the one bucket full and the operator's own correct password
-// forever. There is no second administrative path.
+// is answered 429 forever. There is no second administrative path.
 //
 // So budget is spent only by a FAILED verification. A correct
 // password is never throttled, whatever the counters say, which is

internal/middleware/ratelimit.go

@@ -123,9 +123,8 @@ func bucketKey(addr netip.Addr) string {
 	return prefix.String()
 }
 
-// isTrustedProxy reports whether addr belongs to a network the
+// isTrustedProxy reports whether addr belongs to a network in
-// operator listed in TRUSTED_PROXIES. The list is empty by default,
+// TRUSTED_PROXIES, which by default is the RFC 1918 private ranges.
-// so by default nothing is trusted.
 func (m *Middleware) isTrustedProxy(addr netip.Addr) bool {
 	for _, prefix := range m.params.Config.TrustedProxies {
 		if prefix.Contains(addr) {

internal/middleware/ratelimit_test.go

@@ -384,8 +384,8 @@ const (
 	// trustedProxyCIDR is the proxy network the forwarded-path
 	// tests configure, and trustedPeer an address inside it. A
 	// production deployment is required to run behind a reverse
-	// proxy with TRUSTED_PROXIES set, so this is the shape the
+	// proxy that TRUSTED_PROXIES covers, either by the default or by
-	// bucketing has to hold in.
+	// a set value, so this is the shape the bucketing has to hold in.
 	trustedProxyCIDR = "10.0.0.0/8"
 	trustedPeer      = "10.0.0.1:44444"
 )
@@ -426,8 +426,8 @@ func assertSharedBucket(
 }
 
 // TestRateLimitKey_SpoofedForwardedFromUntrustedPeer is the test
-// this gating exists for: with no trusted proxies configured (the
+// this gating exists for: from a peer that is not a trusted
-// default), a client that rotates a forwarded header on every
+// proxy, a client that rotates a forwarded header on every
 // request must stay in one bucket. If forwarded headers were
 // trusted unconditionally, each spoofed value would mint a fresh
 // bucket and the limit would stop no one.
@@ -1097,8 +1097,9 @@ func TestPostRateLimit_IPv4IndependentPerAddress(t *testing.T) {
 // that arrives from trustedPeer — a configured trusted proxy — and
 // names forwarded as its client in X-Forwarded-For. That is the
 // production path: a deployment is required to run behind a reverse
-// proxy with TRUSTED_PROXIES set, so the forwarded address, not the
+// proxy that TRUSTED_PROXIES covers, either by the default or by a
-// peer, is what the limiters bucket on there.
+// set value, so the forwarded address, not the peer, is what the
+// limiters bucket on there.
 func forwardedKeyFor(
 	t *testing.T, m *middleware.Middleware, forwarded string,
 ) string {
@@ -1178,9 +1179,9 @@ func TestRateLimitKey_ForwardedIPv6BucketsByPrefix(t *testing.T) {
 //
 // Every existing test of this fallback uses an IPv4 proxy, where
 // bucketKey is the identity function, so replacing the call with
-// peer.String() leaves the whole suite green. Only operator-listed
+// peer.String() leaves the whole suite green. Only addresses inside
-// addresses reach this line and the fallback is fail-closed, so this
+// TRUSTED_PROXIES reach this line and the fallback is fail-closed, so
-// pins behaviour rather than fixing a defect.
+// this pins behaviour rather than fixing a defect.
 func TestRateLimitKey_TrustedPeerUnusableForwardedMasksPeer(
 	t *testing.T,
 ) {

internal/server/routes.go

@@ -154,11 +154,12 @@ func (s *Server) setupPageRoutes() {
 		r.Use(s.mw.NoCache())
 
 		// The login POST carries no pre-emptive rate limiter. Behind
-		// the reverse proxy production requires, with TRUSTED_PROXIES
+		// the reverse proxy production requires, when TRUSTED_PROXIES
-		// unset, every client shares one bucket, so a limiter spent
+		// does not cover it, every client shares one bucket, so a
-		// on arrival lets any stranger deny the operator the only
+		// limiter spent on arrival lets any stranger deny the operator
-		// administrative path. The handler verifies credentials first
+		// the only administrative path. The handler verifies
-		// and charges only failures; see Handlers.authenticateUser.
+		// credentials first and charges only failures; see
+		// Handlers.authenticateUser.
 		r.Get("/login", s.h.HandleLoginPage())
 		r.Post("/login", s.h.HandleLoginSubmit())
 

internal/versionscript/version_script_test.go

@@ -115,8 +115,8 @@ func TestVersion_EnclosingRepositoryIsNotUsed(t *testing.T) {
 	require.Equal(t, unknown, runScript(t, inner, nil))
 }
 
-// An explicit VERSION, such as the Dockerfile's build arg, wins over
+// The Docker build has no git metadata, so the version arrives as an
-// anything derivable.
+// environment override. It wins over anything derivable.
 func TestVersion_EnvironmentOverrideWins(t *testing.T) {
 	t.Parallel()
 
@@ -128,8 +128,8 @@ func TestVersion_EnvironmentOverrideWins(t *testing.T) {
 }
 
 // An empty VERSION is treated as unset rather than stamping an empty
-// string: a caller exporting VERSION= must not produce a binary
+// string: the Dockerfile's build arg has a non-empty default, but a
-// reporting "".
+// caller exporting VERSION= must not produce a binary reporting "".
 func TestVersion_EmptyOverrideFallsBackToGit(t *testing.T) {
 	t.Parallel()
 
@@ -168,8 +168,8 @@ func TestMakefile_BuildComposesVersionAndExtraFlags(t *testing.T) {
 }
 
 // A caller can define VERSION as the empty string -- `make build
-// VERSION=`, or the Dockerfile's `make build VERSION="$VERSION"` when no
+// VERSION=`, or a `--build-arg VERSION=` reaching the Dockerfile's `make
-// VERSION build arg was given. script/version's own guard does not cover
+// build VERSION="$VERSION"`. script/version's own guard does not cover
 // that: the value never passes through the script. Stamping "" would
 // leave the binary reporting no version and the footer on "dev", which
 // is the defect this package exists for.
@@ -231,7 +231,7 @@ func TestDockerfile_BuildsThroughTheMakeTarget(t *testing.T) {
 
 	require.NotContains(t, dockerfile, "go build",
 		"a raw go build bypasses the Makefile's -X flag")
-	require.Contains(t, dockerfile, "ARG VERSION")
+	require.Contains(t, dockerfile, "ARG VERSION=")
 	require.Contains(t, dockerfile,
 		`make build VERSION="$VERSION" GO_LDFLAGS='-extldflags "-static"'`)
 }

script/docker

@@ -2,9 +2,9 @@
 # script/docker: build the Docker image tagged with the project name.
 # The tag comes from script/projectname.
 #
-# The version script/version resolves here goes in as the VERSION build
+# .dockerignore excludes .git/, so the builder stage cannot derive the
-# arg, which takes precedence over what the build would derive from the
+# version itself. It is resolved here, where the checkout is, and passed
-# .git in its context.
+# in as a build arg; without it the image would stamp itself "unknown".
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"

script/version

@@ -7,16 +7,18 @@
 #
 # Order of precedence:
 #
-#   1. $VERSION, if set and non-empty: an explicit value, such as the
+#   1. $VERSION, if set and non-empty. This is how the value reaches a
-#      Dockerfile's VERSION build arg.
+#      build that cannot derive it: .dockerignore excludes .git/, so the
+#      builder stage has no git metadata and the Dockerfile takes the
+#      value as a build arg instead.
 #   2. `git describe --tags --always --dirty` against this checkout. At
 #      a clean tagged commit that is exactly the tag; otherwise it
 #      carries the short SHA, the commit distance when a tag is
 #      reachable, and a -dirty suffix for uncommitted changes.
 #   3. "unknown", for a tree with no git metadata and no $VERSION -- a
-#      source tarball, or a `docker build` with no .git in its context
+#      source tarball, or `docker build .` with no --build-arg. That
-#      and no VERSION build arg. That case must not fail the build and
+#      case must not fail the build and must not name a tag the tree may
-#      must not name a tag the tree may not be at, so it names nothing.
+#      not be at, so it names nothing.
 #
 # The git step insists the enclosing repository is this checkout, not
 # merely some repository above it: an unpacked tarball sitting inside an