fix(backend): rate-limit and cap report ingest, drop wildcard CORS (closes #20)

POST /api/v1/reports stays unauthenticated but is bounded. Each client
address, as the trusted-proxy logic resolves it, may send
REPORTS_PER_MINUTE reports a minute (default 60), counted by
go-chi/httprate over a sliding minute; past that it gets 429 with
Retry-After. reportbuf refuses a report that would take the report
files past DATA_DIR_MAX_BYTES (default 1 GiB) with ErrFull, answered
with 507; the count starts from the files already in DATA_DIR, and
reports not yet written count at their uncompressed size. CORS adds
nothing unless CORS_ALLOWED_ORIGINS lists origins. A limit that is
not a positive number stops the server from starting.

Model: opus-5-5

Dockerfile

@@ -68,11 +68,8 @@ FROM nginx@sha256:15e96e59aa3b0aada3a121296e3bce117721f42d88f5f64217ef4b18f458c6
 RUN addgroup -g 1000 -S netwatch && \
     adduser -u 1000 -S netwatch -G netwatch
 
-# At start-up the nginx image renders every template here into
-# conf.d; bin/entrypoint.sh says how.
 RUN rm /etc/nginx/conf.d/default.conf
-COPY nginx.conf /etc/nginx/templates/netwatch.conf.template
+COPY nginx.conf /etc/nginx/conf.d/netwatch.conf
-COPY security-headers.conf /etc/nginx/security-headers.conf
 COPY --from=frontend /app/dist /usr/share/nginx/html
 COPY --from=builder /src/netwatch-server /usr/local/bin/netwatch-server
 COPY bin/entrypoint.sh /usr/local/bin/entrypoint.sh
@@ -81,15 +78,8 @@ ENV DATA_DIR=/data/reports
 RUN mkdir -p /data/reports && chown -R netwatch:netwatch /data
 VOLUME /data
 
-# The default public port; PORT changes it.
 EXPOSE 8080
 
-# Requests the backend's health check through nginx, on the port from
-# PORT, so it fails unless both answer. upaas reads the result 60
-# seconds after a deploy and fails the deploy unless it is healthy.
-HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
-    CMD wget -q -O /dev/null "http://127.0.0.1:${PORT:-8080}/.well-known/healthcheck"
-
 # The nginx image stops its container with SIGQUIT; the entrypoint
 # acts on TERM and INT.
 STOPSIGNAL SIGTERM

README.md

@@ -184,64 +184,16 @@ container: nginx serves the built frontend and passes `/api/` and
 only inside the container, on `127.0.0.1:8081`. The image:
 
 - Listens on port 8080 by default (override with `PORT` env var)
-- Takes the client address from `X-Forwarded-For` only on requests from the
+- Trusts `X-Forwarded-For` from RFC1918 reverse proxies (10/8, 172.16/12,
-  reverse proxies named in `TRUSTED_PROXIES`, and by default from none
+  192.168/16)
 - Sends access logs to stdout
 - Caches static assets with immutable headers
-- Sends the security headers `REPO_POLICIES.md` requires on every response, as
-  `security-headers.conf` sets them, in place of the backend's own
 - Stores reports in `DATA_DIR`, `/data/reports` by default, on the `/data`
   volume. The backend runs as user `netwatch` (uid 1000), so a directory
   bind-mounted at `/data` must be writable by uid 1000
 - Writes buffered reports to disk on `docker stop`, and exits non-zero if nginx
   or the backend exits on its own, so the platform restarts it
 
-## Running under upaas
-
-What the [upaas](https://git.eeqj.de/sneak/upaas) app for netwatch needs:
-
-- **Port:** container port `8080`.
-- **Volume:** container path `/data`; the reports are kept in `/data/reports`.
-- **First run:** upaas bind-mounts the host directory it is given and does not
-  create it, and the backend, which runs as uid 1000, does not start unless it
-  can write there. Create the directory, owned by uid 1000, before the first
-  deploy:
-
-    ```bash
-    mkdir -p /path/to/data
-    chown 1000:1000 /path/to/data
-    ```
-
-- **Environment variables:** none is required. An empty one counts as unset, and
-  one set to a value netwatch cannot use stops the container at start, with the
-  reason in its log.
-    - `PORT`, default `8080`: the container port, from 1 to 65535. `8081` cannot
-      be used: the backend listens on it inside the container
-    - `REPORTS_PER_MINUTE`, default `60`: reports each client address may send a
-      minute
-    - `DATA_DIR_MAX_BYTES`, default `1073741824` (1 GiB): the most room the
-      report files may take
-    - `CORS_ALLOWED_ORIGINS`, default empty: other origins whose pages may call
-      the API
-    - `DEBUG`, default `false`: debug logging
-    - `DATA_DIR`, default `/data/reports`: leave unset; reports kept outside
-      `/data` do not survive a redeploy
-    - `TRUSTED_PROXIES`, default empty: set it to the address the reverse proxy
-      in front of the container connects from, as an IP address or CIDR; several
-      are separated by commas. nginx takes the client address from
-      `X-Forwarded-For` only on a request from one of them, and the rate limit
-      counts that address. Unset, `X-Forwarded-For` is ignored and every client
-      behind the proxy shares the proxy's one allowance of `REPORTS_PER_MINUTE`.
-      Name only addresses nothing but the proxy connects from: any client that
-      connects from one can write its own `X-Forwarded-For`, and through a port
-      Docker publishes, every client may connect from the Docker network's
-      gateway, such as `172.17.0.1`.
-- **Health check:** the image's `HEALTHCHECK` requests
-  `/.well-known/healthcheck` through nginx every 30 seconds, so it fails unless
-  both nginx and the backend answer. upaas reads the container's health 60
-  seconds after a deploy and fails the deploy unless it is `healthy`. The
-  container also stops when either process exits.
-
 ## Browser Compatibility
 
 Requires a modern browser with ES modules, Fetch API, Canvas API, and CSS custom

TODO.md

@@ -23,51 +23,6 @@ latest run passes.
 
 # Completed Steps
 
-- 2026-09-29: nginx sends the security headers `REPO_POLICIES.md` requires on
-  every response (issue #18), including errors, `/assets/` and what it passes on
-  from the backend, whose own copies it drops so each header goes out once. They
-  live in `security-headers.conf`, which `nginx.conf` includes. The content
-  security policy allows no inline script or style, so the status dot's grey in
-  `src/main.js` is now a class; `connect-src` is `*` because probed hosts
-  redirect to others, and the browser checks each redirect against it
-- 2026-09-29: the request log is bounded (issue #60): the method, URL, protocol,
-  `User-Agent`, `Referer`, request ID (which chi takes from the client's
-  `X-Request-Id` header) and client address it writes are each cut to 128 bytes,
-  the bound the report handler already used, so one request can no longer put
-  about 1 MiB per field into a log line. That bound and its helper now live in
-  the `logger` package, shared by both
-- 2026-09-29: nginx takes the client address from `X-Forwarded-For` only on
-  requests from the reverse proxies named in the container's `TRUSTED_PROXIES`
-  (issue #64), and by default from none, where it trusted every RFC1918 address
-  before, so a client could write a new address on each request and escape the
-  rate limit. `bin/entrypoint.sh` writes one `set_real_ip_from` line per entry
-  into `/etc/nginx/trusted-proxies.conf`, which `nginx.conf` includes, refusing
-  an entry that is not an IP address or CIDR, as `netwatch-server check-cidr`
-  finds; it starts the backend with `TRUSTED_PROXIES=127.0.0.1/32`, since nginx
-  is its only client
-- 2026-09-29: report file names can no longer collide (issue #61): each is
-  `reports-<timestamp>-<number>.jsonl.zst`, where the number goes up by one for
-  each file the server starts to write, so two flushes in the same millisecond,
-  such as a flush for size and the final flush at shutdown, each get a file of
-  their own instead of the second one failing. A failed write uses up its
-  number, leaving a gap if the file could not be created and otherwise a file
-  under that number that may be incomplete.
-- 2026-09-29: ready to run under upaas (issue #59): the image has a
-  `HEALTHCHECK` that requests `/.well-known/healthcheck` through nginx on the
-  port from `PORT`. The backend no longer reads a bad `PORT` as 0 or a bad
-  `DEBUG` as false: those, and a `BIND_ADDRESS` that is not an IP address, stop
-  it from starting with an error naming the variable, as the limits,
-  `CORS_ALLOWED_ORIGINS` and, now by name, `TRUSTED_PROXIES` already did.
-  `bin/entrypoint.sh` also refuses a `PORT` outside 1 to 65535, and `8081`,
-  where the backend listens inside the container, naming `PORT`. `README.md` has
-  a "Running under upaas" section, whose first-run steps create the host
-  directory for `/data` owned by uid 1000; the image does not change its owner
-- 2026-09-29: nginx listens on `PORT` (issue #26), 8080 when unset or empty: the
-  nginx image renders `nginx.conf` as a template at container start, filling in
-  `PORT` and no other variable. `bin/entrypoint.sh` refuses to start when `PORT`
-  is not digits only. `server_tokens off` keeps the nginx version out of
-  responses. `script/frontend-viewport-test` renders the template the same way.
-  Gzip and a `50x.html` error page are not added
 - 2026-09-29: bounded the report endpoint (issue #20): `POST /api/v1/reports`
   still needs no credentials, but each client address, as resolved through
   `TRUSTED_PROXIES`, may send `REPORTS_PER_MINUTE` (default 60) reports a
@@ -75,9 +30,8 @@ latest run passes.
   `Retry-After`; the report files in `DATA_DIR`, counted from start with those
   already there, may total at most `DATA_DIR_MAX_BYTES` (default 1 GiB), past
   which reports get 507; and the wildcard CORS is gone: no CORS headers unless
-  `CORS_ALLOWED_ORIGINS` lists origins, and an entry that is not a plain
+  `CORS_ALLOWED_ORIGINS` lists origins. Deleting report files frees room only at
-  `scheme://host[:port]` origin, `*` included, stops the server from starting.
+  the next start; pruning is issue #54
-  Deleting report files frees room only at the next start; pruning is issue #54
 - 2026-09-28: one container image (issue #52): the root `Dockerfile` builds the
   only image, and `Dockerfile.backend` is gone. nginx serves the frontend on
   port 8080 and proxies `/api/` and `/.well-known/healthcheck` to the backend,

backend/README.md

@@ -80,21 +80,16 @@ Internal packages in `internal/` follow standard Go project layout:
 | `BIND_ADDRESS`         | empty                | IP address to listen on; empty listens on every interface                                                |
 | `PORT`                 | `8080`               | HTTP listen port                                                                                         |
 | `DATA_DIR`             | `./data/reports`     | Directory for compressed reports                                                                         |
-| `DATA_DIR_MAX_BYTES`   | `1073741824` (1 GiB) | Largest total size of the report files in `DATA_DIR`; see [Report limits](#report-limits)                |
+| `DATA_DIR_MAX_BYTES`   | `1073741824` (1 GiB) | Most the report files in `DATA_DIR` may total; see [Report limits](#report-limits)                       |
 | `DEBUG`                | `false`              | Enable debug logging                                                                                     |
 | `TRUSTED_PROXIES`      | loopback + RFC1918   | Comma-separated CIDRs whose `X-Forwarded-For` / `X-Real-IP` headers are trusted for client IP resolution |
 | `REPORTS_PER_MINUTE`   | `60`                 | Reports each client address may send a minute; see [Report limits](#report-limits)                       |
 | `CORS_ALLOWED_ORIGINS` | empty                | Comma-separated origins whose pages may call the API; see [CORS](#cors)                                  |
 
 `TRUSTED_PROXIES` defaults to `127.0.0.1/32,::1/128,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16`.
-The loopback entries cover a reverse proxy on the same host. A request whose
+The loopback entries cover the reverse proxy that shares the container; the
-direct peer is outside this set has its forwarded headers ignored, and the
+RFC1918 ranges match `nginx.conf`. A request whose direct peer is outside this
-direct peer is logged and rate-limited instead. The container image does not use
+set has its forwarded headers ignored, and the direct peer is logged instead.
-this default; see [Container image](#container-image).
-
-A variable set to a value the server cannot use, such as `PORT=abc`,
-`DEBUG=maybe` or a `BIND_ADDRESS` that is not an IP address, stops it from
-starting, with an error naming the variable. An empty variable counts as unset.
 
 ### Container image
 
@@ -102,32 +97,14 @@ The root `Dockerfile` builds one image in which nginx listens on the public port
 8080, serves the frontend, and proxies `/api/` and `/.well-known/healthcheck` to
 this server. The image's entrypoint, `bin/entrypoint.sh`, starts the server as
 user `netwatch` (uid 1000) with `BIND_ADDRESS=127.0.0.1` and `PORT=8081`, so
-only nginx reaches it, and with `TRUSTED_PROXIES=127.0.0.1/32`, so it takes the
+only nginx reaches it. `DATA_DIR` is `/data/reports`, on the `/data` volume,
-client address nginx passes on and no other. `DATA_DIR` is `/data/reports`, on
+which `netwatch` owns.
-the `/data` volume, which `netwatch` owns. nginx replaces the security headers
-this server sets with those in the root `security-headers.conf`, so those are
-what clients of the image see.
-
-The container's own `TRUSTED_PROXIES` goes to nginx instead: IP addresses or
-CIDRs, separated by commas, of the reverse proxies in front of the container.
-nginx takes the client address from `X-Forwarded-For` only on a request from one
-of them. Unset or empty, nginx trusts no proxy, and the client address is the
-one each request comes from, so every client behind a proxy shares one rate
-limit. An entry that is not an IP address or CIDR, such as a hostname or
-`1.2.3`, stops the container at start with an error naming `TRUSTED_PROXIES`:
-the entrypoint checks each entry with `netwatch-server check-cidr`, which parses
-it as this server parses its own `TRUSTED_PROXIES`.
 
 ### Report storage
 
-Reports are written as `reports-<timestamp>-<number>.jsonl.zst` files in
+Reports are written as `reports-<timestamp>.jsonl.zst` files in `DATA_DIR`.
-`DATA_DIR`. The timestamp is in UTC to the millisecond, so the names sort by
+Each file contains one JSON object per line, compressed with zstd. Files are
-time. The number starts at 1 when the server starts and goes up by one for each
+created with `O_EXCL` to prevent overwrites.
-file the server starts to write, so two files written in the same millisecond
-still get different names. A failed write uses up its number, leaving a gap in
-the numbers if the file could not be created and otherwise a file under that
-number that may be incomplete. Each file contains one JSON object per line,
-compressed with zstd. Files are created with `O_EXCL` to prevent overwrites.
 
 ### Report limits
 
@@ -159,10 +136,7 @@ The page calls the API from the origin it is served from, so by default the
 server sends no CORS headers, and browsers let no other origin's pages call it.
 To serve the page from elsewhere, list that origin in `CORS_ALLOWED_ORIGINS`
 (for example `https://netwatch.example.com`); pages from a listed origin may
-`GET` and `POST` with a `Content-Type` header. Each entry must be a plain
+`GET` and `POST` with a `Content-Type` header.
-origin, `scheme://host` with an optional `:port`, as browsers send it: no path,
-not even a trailing `/`, and no `*`. Any other entry stops the server from
-starting, with an error naming `CORS_ALLOWED_ORIGINS`.
 
 ## TODO
 

backend/cmd/netwatch-server/main.go

@@ -2,9 +2,6 @@
 package main
 
 import (
-	"fmt"
-	"os"
-
 	"sneak.berlin/go/netwatch/internal/config"
 	"sneak.berlin/go/netwatch/internal/globals"
 	"sneak.berlin/go/netwatch/internal/handlers"
@@ -25,19 +22,6 @@ var (
 )
 
 func main() {
-	// "netwatch-server check-cidr CIDR" exits 1, with the error, if
-	// this server would refuse CIDR in its TRUSTED_PROXIES.
-	// bin/entrypoint.sh runs it on each entry it gives nginx.
-	if len(os.Args) == 3 && os.Args[1] == "check-cidr" {
-		_, err := middleware.ParseTrustedProxies(os.Args[2:])
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-
-		return
-	}
-
 	globals.Appname = Appname
 	globals.Version = Version
 	globals.Buildarch = Buildarch

backend/internal/config/config.go

@@ -6,10 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
-	"math"
-	"net/netip"
-	"net/url"
-	"strconv"
 	"strings"
 
 	"sneak.berlin/go/netwatch/internal/globals"
@@ -21,11 +17,10 @@ import (
 )
 
 // defaultTrustedProxies lists the networks whose forwarded
-// headers are honoured by default: IPv4 and IPv6 loopback,
+// headers are honoured by default. It covers the RFC1918
-// for a reverse proxy on the same host, and the RFC1918
+// ranges (to match nginx.conf) plus IPv4 and IPv6 loopback,
-// ranges. The container image does not use it:
+// because the reverse proxy shares the container and reaches
-// bin/entrypoint.sh gives the server 127.0.0.1/32, since
+// the backend over loopback.
-// nginx is its only client there.
 const defaultTrustedProxies = "127.0.0.1/32,::1/128," +
 	"10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
 
@@ -36,15 +31,7 @@ const (
 	defaultDataDirMaxBytes  = 1 << 30 // 1 GiB
 )
 
-var (
+var errNotPositive = errors.New("must be a positive whole number")
-	errNotPositive = errors.New("must be a positive whole number")
-	errNotOrigin   = errors.New(
-		"must be an origin, scheme://host with an optional port",
-	)
-	errNotPort = errors.New("must be a port number, 1 to 65535")
-	errNotBool = errors.New("must be true or false")
-	errNotIP   = errors.New("must be an IP address, or empty")
-)
 
 // Params defines the dependencies for Config.
 type Params struct {
@@ -72,8 +59,7 @@ type Config struct {
 }
 
 // New loads configuration from env, .env files, and config
-// files, returning a fully resolved Config. It fails, with an error
+// files, returning a fully resolved Config.
-// naming the setting, on a value the server cannot use.
 func New(
 	_ fx.Lifecycle,
 	params Params,
@@ -111,29 +97,15 @@ func New(
 		}
 	}
 
-	// Read with strconv: viper's GetInt and GetBool would read a value
-	// they cannot parse as 0 or false instead of failing.
-	port, err := strconv.Atoi(viper.GetString("PORT"))
-	if err != nil || port < 1 || port > math.MaxUint16 {
-		return nil, fmt.Errorf("PORT %q: %w",
-			viper.GetString("PORT"), errNotPort)
-	}
-
-	debug, err := strconv.ParseBool(viper.GetString("DEBUG"))
-	if err != nil {
-		return nil, fmt.Errorf("DEBUG %q: %w",
-			viper.GetString("DEBUG"), errNotBool)
-	}
-
 	s := &Config{
 		BindAddress:        viper.GetString("BIND_ADDRESS"),
 		CORSAllowedOrigins: splitList(viper.GetString("CORS_ALLOWED_ORIGINS")),
 		DataDir:            viper.GetString("DATA_DIR"),
 		DataDirMaxBytes:    viper.GetInt64("DATA_DIR_MAX_BYTES"),
-		Debug:              debug,
+		Debug:              viper.GetBool("DEBUG"),
 		MetricsPassword:    viper.GetString("METRICS_PASSWORD"),
 		MetricsUsername:    viper.GetString("METRICS_USERNAME"),
-		Port:               port,
+		Port:               viper.GetInt("PORT"),
 		ReportsPerMinute:   viper.GetInt("REPORTS_PER_MINUTE"),
 		SentryDSN:          viper.GetString("SENTRY_DSN"),
 		TrustedProxies:     splitList(viper.GetString("TRUSTED_PROXIES")),
@@ -141,9 +113,16 @@ func New(
 		params:             &params,
 	}
 
-	err = s.check()
+	// viper reads a value that is not a number as 0, so this also
-	if err != nil {
+	// catches a mistyped setting.
-		return nil, err
+	if s.ReportsPerMinute <= 0 {
+		return nil, fmt.Errorf("REPORTS_PER_MINUTE %q: %w",
+			viper.GetString("REPORTS_PER_MINUTE"), errNotPositive)
+	}
+
+	if s.DataDirMaxBytes <= 0 {
+		return nil, fmt.Errorf("DATA_DIR_MAX_BYTES %q: %w",
+			viper.GetString("DATA_DIR_MAX_BYTES"), errNotPositive)
 	}
 
 	if s.Debug {
@@ -154,51 +133,6 @@ func New(
 	return s, nil
 }
 
-// check fails with an error naming the first setting here whose value
-// the server cannot use. New checks PORT and DEBUG as it reads them,
-// and the middleware checks TRUSTED_PROXIES as it parses it.
-func (s *Config) check() error {
-	// viper reads a value that is not a number as 0, so this also
-	// catches a mistyped setting.
-	if s.ReportsPerMinute <= 0 {
-		return fmt.Errorf("REPORTS_PER_MINUTE %q: %w",
-			viper.GetString("REPORTS_PER_MINUTE"), errNotPositive)
-	}
-
-	if s.DataDirMaxBytes <= 0 {
-		return fmt.Errorf("DATA_DIR_MAX_BYTES %q: %w",
-			viper.GetString("DATA_DIR_MAX_BYTES"), errNotPositive)
-	}
-
-	if s.BindAddress != "" {
-		_, err := netip.ParseAddr(s.BindAddress)
-		if err != nil {
-			return fmt.Errorf("BIND_ADDRESS %q: %w", s.BindAddress, errNotIP)
-		}
-	}
-
-	return checkOrigins(s.CORSAllowedOrigins)
-}
-
-// checkOrigins fails on the first CORS_ALLOWED_ORIGINS entry that is
-// not a plain origin, scheme://host with an optional port, as browsers
-// send it; anything more, such as a trailing "/", would match no page.
-// go-chi/cors reads a "*" anywhere in an entry as a wildcard, so no
-// entry may contain one.
-func checkOrigins(origins []string) error {
-	for _, origin := range origins {
-		u, err := url.Parse(origin)
-		if err != nil || u.Scheme == "" || u.Host == "" ||
-			strings.Contains(origin, "*") ||
-			origin != u.Scheme+"://"+u.Host {
-			return fmt.Errorf("CORS_ALLOWED_ORIGINS %q: %w",
-				origin, errNotOrigin)
-		}
-	}
-
-	return nil
-}
-
 // splitList turns a comma-separated setting into a trimmed
 // slice, dropping empty entries.
 func splitList(raw string) []string {

backend/internal/config/config_test.go

@@ -29,63 +29,6 @@ func requireConfigError(t *testing.T, setting string) {
 	}
 }
 
-// TestSettingsLoadAsGiven: valid values pass the checks and are used
-// as given. bin/entrypoint.sh starts the server with these
-// BIND_ADDRESS and PORT values.
-func TestSettingsLoadAsGiven(t *testing.T) {
-	t.Setenv("BIND_ADDRESS", "127.0.0.1")
-	t.Setenv("PORT", "8081")
-	t.Setenv("DEBUG", "true")
-
-	var cfg *config.Config
-
-	app := fx.New(
-		fx.NopLogger,
-		fx.Provide(globals.New, logger.New, config.New),
-		fx.Populate(&cfg),
-	)
-
-	err := app.Err()
-	if err != nil {
-		t.Fatalf("config error = %v", err)
-	}
-
-	if cfg.BindAddress != "127.0.0.1" || cfg.Port != 8081 || !cfg.Debug {
-		t.Fatalf("BindAddress, Port, Debug = %q, %d, %t; "+
-			"want \"127.0.0.1\", 8081, true",
-			cfg.BindAddress, cfg.Port, cfg.Debug)
-	}
-}
-
-// TestPortMustBeAPortNumber: viper reads a value that is not a number
-// as 0, on which the server would listen on a random port.
-func TestPortMustBeAPortNumber(t *testing.T) {
-	for _, value := range []string{"abc", "0", "65536", "8080.5"} {
-		t.Run(value, func(t *testing.T) {
-			t.Setenv("PORT", value)
-
-			requireConfigError(t, "PORT")
-		})
-	}
-}
-
-// TestDebugMustBeTrueOrFalse: viper reads any other value, such as
-// "yes", as false.
-func TestDebugMustBeTrueOrFalse(t *testing.T) {
-	t.Setenv("DEBUG", "yes")
-
-	requireConfigError(t, "DEBUG")
-}
-
-// TestBindAddressMustBeAnIPAddress: a host name would be looked up
-// only once the server starts listening, and a mistyped one would stop
-// it then with an error that does not name the setting.
-func TestBindAddressMustBeAnIPAddress(t *testing.T) {
-	t.Setenv("BIND_ADDRESS", "localhost")
-
-	requireConfigError(t, "BIND_ADDRESS")
-}
-
 // TestReportsPerMinuteMustBePositive: unchecked, zero would panic
 // when the routes are built, and a negative rate would lift the
 // limit.
@@ -102,20 +45,3 @@ func TestDataDirMaxBytesMustBeANumber(t *testing.T) {
 
 	requireConfigError(t, "DATA_DIR_MAX_BYTES")
 }
-
-// TestCORSAllowedOriginsMustBeOrigins: "*" would let every origin in,
-// and an entry that is not a plain origin would match no page.
-func TestCORSAllowedOriginsMustBeOrigins(t *testing.T) {
-	for _, entry := range []string{
-		"*",
-		"https://*.netwatch.example",
-		"netwatch.example",
-		"https://netwatch.example/",
-	} {
-		t.Run(entry, func(t *testing.T) {
-			t.Setenv("CORS_ALLOWED_ORIGINS", entry)
-
-			requireConfigError(t, "CORS_ALLOWED_ORIGINS")
-		})
-	}
-}

backend/internal/handlers/export_test.go

@@ -2,6 +2,9 @@ package handlers
 
 import "log/slog"
 
+// MaxLoggedFieldBytes exposes the log bound to the external tests.
+const MaxLoggedFieldBytes = maxLoggedFieldBytes
+
 // NewForTest builds a Handlers around a report sink and logger,
 // bypassing the fx graph so handler behaviour (including the
 // storage failure path) is exercisable in unit tests.

backend/internal/handlers/report.go

@@ -5,10 +5,14 @@ import (
 	"errors"
 	"net/http"
 
-	"sneak.berlin/go/netwatch/internal/logger"
 	"sneak.berlin/go/netwatch/internal/reportbuf"
 )
 
+// maxLoggedFieldBytes bounds untrusted text (string fields,
+// decode error text) before it is logged, so a caller cannot
+// inflate log volume with an oversized value.
+const maxLoggedFieldBytes = 128
+
 type reportSample struct {
 	T       int64   `json:"t"`
 	Latency *int    `json:"latency"`
@@ -79,7 +83,7 @@ func (s *Handlers) decodeErrorStatus(err error) int {
 	// The decoder's error text can quote request bytes (a whole
 	// oversized number, for example), so it is bounded too.
 	s.log.Error("failed to decode report",
-		"error", logger.BoundedForLog(err.Error()),
+		"error", boundedForLog(err.Error()),
 	)
 
 	return http.StatusBadRequest
@@ -111,10 +115,20 @@ func (s *Handlers) logReportReceived(rpt report) {
 	}
 
 	s.log.Info("report received",
-		"client_id", logger.BoundedForLog(rpt.ClientID),
+		"client_id", boundedForLog(rpt.ClientID),
-		"timestamp", logger.BoundedForLog(rpt.Timestamp),
+		"timestamp", boundedForLog(rpt.Timestamp),
 		"host_count", len(rpt.Hosts),
 		"total_samples", totalSamples,
 		"geo_bytes", len(rpt.Geo),
 	)
 }
+
+// boundedForLog truncates an untrusted string to a fixed byte
+// bound so an attacker-controlled field cannot dominate the log.
+func boundedForLog(s string) string {
+	if len(s) > maxLoggedFieldBytes {
+		return s[:maxLoggedFieldBytes]
+	}
+
+	return s
+}

backend/internal/handlers/report_test.go

@@ -12,7 +12,6 @@ import (
 	"testing"
 
 	"sneak.berlin/go/netwatch/internal/handlers"
-	"sneak.berlin/go/netwatch/internal/logger"
 	"sneak.berlin/go/netwatch/internal/middleware"
 	"sneak.berlin/go/netwatch/internal/reportbuf"
 )
@@ -175,7 +174,7 @@ func TestHandleReportDoesNotLogRawGeo(t *testing.T) {
 func TestHandleReportLogsClientIDCutToBound(t *testing.T) {
 	t.Parallel()
 
-	long := strings.Repeat("c", 2*logger.MaxLoggedFieldBytes)
+	long := strings.Repeat("c", 2*handlers.MaxLoggedFieldBytes)
 
 	var logbuf bytes.Buffer
 
@@ -198,16 +197,16 @@ func TestHandleReportLogsClientIDCutToBound(t *testing.T) {
 		t.Fatalf("log line not JSON: %v (%q)", err, logbuf.String())
 	}
 
-	want := long[:logger.MaxLoggedFieldBytes]
+	want := long[:handlers.MaxLoggedFieldBytes]
 
 	if logged["client_id"] != want {
 		t.Fatalf("logged client_id not cut to %d bytes: %q",
-			logger.MaxLoggedFieldBytes, logged["client_id"])
+			handlers.MaxLoggedFieldBytes, logged["client_id"])
 	}
 
 	if logged["timestamp"] != want {
 		t.Fatalf("logged timestamp not cut to %d bytes: %q",
-			logger.MaxLoggedFieldBytes, logged["timestamp"])
+			handlers.MaxLoggedFieldBytes, logged["timestamp"])
 	}
 }
 
@@ -216,7 +215,7 @@ func TestHandleReportDecodeErrorLogIsBounded(t *testing.T) {
 
 	// A number too large for its int64 field makes the decoder's
 	// error text quote the whole number.
-	huge := strings.Repeat("9", 2*logger.MaxLoggedFieldBytes)
+	huge := strings.Repeat("9", 2*handlers.MaxLoggedFieldBytes)
 
 	var logbuf bytes.Buffer
 

backend/internal/logger/logger.go

@@ -11,21 +11,6 @@ import (
 	"go.uber.org/fx"
 )
 
-// MaxLoggedFieldBytes bounds untrusted text (request fields,
-// header values, decode error text) before it is logged, so a
-// caller cannot inflate log volume with an oversized value.
-const MaxLoggedFieldBytes = 128
-
-// BoundedForLog truncates an untrusted string to a fixed byte
-// bound so an attacker-controlled field cannot dominate the log.
-func BoundedForLog(s string) string {
-	if len(s) > MaxLoggedFieldBytes {
-		return s[:MaxLoggedFieldBytes]
-	}
-
-	return s
-}
-
 // Params defines the dependencies for Logger.
 type Params struct {
 	fx.In

backend/internal/middleware/export_test.go

@@ -29,3 +29,7 @@ func ClientIP(
 ) string {
 	return clientIP(remoteAddr, header, trusted)
 }
+
+func ParseTrustedProxies(cidrs []string) ([]netip.Prefix, error) {
+	return parseTrustedProxies(cidrs)
+}

backend/internal/middleware/middleware.go

@@ -64,7 +64,7 @@ func New(
 	_ fx.Lifecycle,
 	params Params,
 ) (*Middleware, error) {
-	trusted, err := ParseTrustedProxies(params.Config.TrustedProxies)
+	trusted, err := parseTrustedProxies(params.Config.TrustedProxies)
 	if err != nil {
 		return nil, err
 	}
@@ -77,18 +77,16 @@ func New(
 	return s, nil
 }
 
-// ParseTrustedProxies converts the TRUSTED_PROXIES entries into
+// parseTrustedProxies converts CIDR strings into prefixes,
-// prefixes, failing fast on any malformed entry. Each entry must be
+// failing fast on any malformed entry.
-// a CIDR; a lone address is refused. "netwatch-server check-cidr"
+func parseTrustedProxies(cidrs []string) ([]netip.Prefix, error) {
-// runs it too.
-func ParseTrustedProxies(cidrs []string) ([]netip.Prefix, error) {
 	prefixes := make([]netip.Prefix, 0, len(cidrs))
 
 	for _, cidr := range cidrs {
 		prefix, err := netip.ParsePrefix(cidr)
 		if err != nil {
 			return nil, fmt.Errorf(
-				"TRUSTED_PROXIES %q: %w", cidr, err,
+				"trusted proxy %q: %w", cidr, err,
 			)
 		}
 
@@ -189,10 +187,7 @@ func addrInAny(s string, trusted []netip.Prefix) bool {
 }
 
 // Logging returns middleware that logs each request with
-// timing, status code, and client information. Every string
+// timing, status code, and client information.
-// taken from the request is cut to logger.MaxLoggedFieldBytes,
-// including the request ID, which chi takes from the client's
-// X-Request-Id header when one is sent.
 func (s *Middleware) Logging() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(
@@ -205,19 +200,21 @@ func (s *Middleware) Logging() func(http.Handler) http.Handler {
 					latency := time.Since(start)
 					s.log.InfoContext(ctx, "request",
 						"request_start", start,
-						"method", logger.BoundedForLog(r.Method),
+						"method", r.Method,
-						"url", logger.BoundedForLog(r.URL.String()),
+						"url", r.URL.String(),
-						"useragent", logger.BoundedForLog(r.UserAgent()),
+						"useragent", r.UserAgent(),
 						"request_id",
-						logger.BoundedForLog(middleware.GetReqID(ctx)),
+						ctx.Value(
-						"referer", logger.BoundedForLog(r.Referer()),
+							middleware.RequestIDKey,
-						"proto", logger.BoundedForLog(r.Proto),
+						),
+						"referer", r.Referer(),
+						"proto", r.Proto,
 						"remote_ip",
-						logger.BoundedForLog(clientIP(
+						clientIP(
 							r.RemoteAddr,
 							r.Header,
 							s.trustedProxies,
-						)),
+						),
 						"status", lrw.statusCode,
 						"latency_ms",
 						latency.Milliseconds(),

backend/internal/middleware/middleware_test.go

@@ -13,10 +13,7 @@ import (
 	"testing/synctest"
 	"time"
 
-	"sneak.berlin/go/netwatch/internal/logger"
 	"sneak.berlin/go/netwatch/internal/middleware"
-
-	chimiddleware "github.com/go-chi/chi/v5/middleware"
 )
 
 const (
@@ -39,32 +36,15 @@ func mustPrefixes(t *testing.T, cidrs ...string) []netip.Prefix {
 	return prefixes
 }
 
-// TestParseTrustedProxiesRejectsMalformed includes entries nginx would
-// read as another address or look up as a hostname, in the CIDR form
-// bin/entrypoint.sh gives "netwatch-server check-cidr".
 func TestParseTrustedProxiesRejectsMalformed(t *testing.T) {
 	t.Parallel()
 
-	for _, cidr := range []string{
+	_, err := middleware.ParseTrustedProxies([]string{"not-a-cidr"})
-		"not-a-cidr", "10.0.0.1", "1.2.3/32", "172.30/32", "10/32",
+	if err == nil {
-		"cafe/32", "999.1.1.1/32", "10.0.0.0/33", "::1/129",
+		t.Fatal("expected error for malformed CIDR, got nil")
-		"fe80::1%eth0/128",
-	} {
-		_, err := middleware.ParseTrustedProxies([]string{cidr})
-		if err == nil || !strings.Contains(err.Error(), "TRUSTED_PROXIES") {
-			t.Errorf("%q: error = %v, want one naming TRUSTED_PROXIES",
-				cidr, err)
-		}
 	}
 }
 
-func TestParseTrustedProxiesAcceptsCIDRs(t *testing.T) {
-	t.Parallel()
-
-	mustPrefixes(t, "172.17.0.1/32", "10.0.0.0/8", "2001:db8::1/128",
-		"2001:db8::/32", "::ffff:192.0.2.1/128")
-}
-
 type clientIPCase struct {
 	name       string
 	remoteAddr string
@@ -323,52 +303,6 @@ func TestRecovererRepanicsOnAbortHandler(t *testing.T) {
 	}
 }
 
-// TestLoggingCutsRequestStringsToBound sends an over-long URL and
-// over-long header values, and checks the request log writes each
-// one cut to logger.MaxLoggedFieldBytes.
-func TestLoggingCutsRequestStringsToBound(t *testing.T) {
-	t.Parallel()
-
-	long := strings.Repeat("a", 2*logger.MaxLoggedFieldBytes)
-
-	var logbuf bytes.Buffer
-
-	mw := middleware.NewWithLogger(
-		slog.New(slog.NewJSONHandler(&logbuf, nil)),
-	)
-
-	handler := chimiddleware.RequestID(mw.Logging()(okHandler()))
-
-	req := httptest.NewRequestWithContext(t.Context(),
-		http.MethodGet, "/"+long, http.NoBody)
-	req.Header.Set("User-Agent", long)
-	req.Header.Set("Referer", long)
-	req.Header.Set("X-Request-Id", long)
-
-	handler.ServeHTTP(httptest.NewRecorder(), req)
-
-	var logged map[string]any
-
-	err := json.Unmarshal(logbuf.Bytes(), &logged)
-	if err != nil {
-		t.Fatalf("log line not JSON: %v (%q)", err, logbuf.String())
-	}
-
-	want := map[string]string{
-		"url":        ("/" + long)[:logger.MaxLoggedFieldBytes],
-		"useragent":  long[:logger.MaxLoggedFieldBytes],
-		"referer":    long[:logger.MaxLoggedFieldBytes],
-		"request_id": long[:logger.MaxLoggedFieldBytes],
-	}
-
-	for field, value := range want {
-		if logged[field] != value {
-			t.Errorf("logged %s = %q, want it cut to %d bytes",
-				field, logged[field], logger.MaxLoggedFieldBytes)
-		}
-	}
-}
-
 // okHandler stands in for the route a middleware guards.
 func okHandler() http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
@@ -433,25 +367,6 @@ func TestRateLimitRefusesPastAllowanceThenResets(t *testing.T) {
 	})
 }
 
-// postForwarded sends handler a report from peer that names client in
-// X-Forwarded-For, and returns the status.
-func postForwarded(
-	t *testing.T,
-	handler http.Handler,
-	peer, client string,
-) int {
-	t.Helper()
-
-	rec := httptest.NewRecorder()
-	req := httptest.NewRequestWithContext(t.Context(),
-		http.MethodPost, "/api/v1/reports", http.NoBody)
-	req.RemoteAddr = peer
-	req.Header.Set("X-Forwarded-For", client)
-	handler.ServeHTTP(rec, req)
-
-	return rec.Code
-}
-
 // TestRateLimitIsPerForwardedClient checks that clients behind a
 // trusted proxy each get their own allowance: the limit is keyed on
 // the client address clientIP resolves, not on the proxy's.
@@ -463,47 +378,32 @@ func TestRateLimitIsPerForwardedClient(t *testing.T) {
 	mw := middleware.NewWithTrustedProxies(mustPrefixes(t, "127.0.0.1/32"))
 	handler := mw.RateLimit(1)(okHandler())
 
-	code := postForwarded(t, handler, loopbackPeer, forwardedIP)
+	post := func(client string) int {
-	if code != http.StatusOK {
+		rec := httptest.NewRecorder()
+		req := httptest.NewRequestWithContext(t.Context(),
+			http.MethodPost, "/api/v1/reports", http.NoBody)
+		req.RemoteAddr = loopbackPeer
+		req.Header.Set("X-Forwarded-For", client)
+		handler.ServeHTTP(rec, req)
+
+		return rec.Code
+	}
+
+	if code := post(forwardedIP); code != http.StatusOK {
 		t.Fatalf("first request: status = %d, want %d", code, http.StatusOK)
 	}
 
-	code = postForwarded(t, handler, loopbackPeer, forwardedIP)
+	if code := post(forwardedIP); code != http.StatusTooManyRequests {
-	if code != http.StatusTooManyRequests {
 		t.Fatalf("same client again: status = %d, want %d",
 			code, http.StatusTooManyRequests)
 	}
 
-	code = postForwarded(t, handler, loopbackPeer, otherClient)
+	if code := post(otherClient); code != http.StatusOK {
-	if code != http.StatusOK {
 		t.Fatalf("other client behind the same proxy: status = %d, want %d",
 			code, http.StatusOK)
 	}
 }
 
-// TestRateLimitIgnoresForwardedForFromUntrustedPeer checks that a
-// peer that is not a trusted proxy cannot get a fresh allowance by
-// naming a different client in X-Forwarded-For on each request.
-func TestRateLimitIgnoresForwardedForFromUntrustedPeer(t *testing.T) {
-	t.Parallel()
-
-	const untrustedPeer = "198.51.100.4:5000"
-
-	mw := middleware.NewWithTrustedProxies(mustPrefixes(t, "127.0.0.1/32"))
-	handler := mw.RateLimit(1)(okHandler())
-
-	code := postForwarded(t, handler, untrustedPeer, "203.0.113.8")
-	if code != http.StatusOK {
-		t.Fatalf("first request: status = %d, want %d", code, http.StatusOK)
-	}
-
-	code = postForwarded(t, handler, untrustedPeer, "203.0.113.9")
-	if code != http.StatusTooManyRequests {
-		t.Fatalf("same peer naming another client: status = %d, want %d",
-			code, http.StatusTooManyRequests)
-	}
-}
-
 // preflight sends cors the preflight request a browser makes before
 // it POSTs JSON from origin.
 func preflight(

backend/internal/reportbuf/export_test.go

@@ -1,15 +1,7 @@
 package reportbuf
 
-import "time"
-
 // Flush writes the buffered reports to a file now, as the periodic
 // flush does, so tests need not wait a minute for it.
 func (b *Buffer) Flush() error {
 	return b.flushLocked()
 }
-
-// StopClock makes every report file the buffer writes from now on
-// carry the timestamp at, as if all were written in one millisecond.
-func (b *Buffer) StopClock(at time.Time) {
-	b.now = func() time.Time { return at }
-}

backend/internal/reportbuf/reportbuf.go

@@ -14,7 +14,6 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"sneak.berlin/go/netwatch/internal/config"
@@ -31,8 +30,7 @@ const (
 	dirPerms           fs.FileMode = 0o750
 	filePerms          fs.FileMode = 0o640
 
-	// Report files are named filePrefix + timestamp + "-" + number +
+	// Report files are named filePrefix + timestamp + fileSuffix.
-	// fileSuffix; see writeFile.
 	filePrefix = "reports-"
 	fileSuffix = ".jsonl.zst"
 )
@@ -58,12 +56,6 @@ type Buffer struct {
 	log      *slog.Logger
 	maxBytes int64
 	mu       sync.Mutex
-	// now is the clock report files are named by: time.Now, except
-	// in tests that need two flushes to share a timestamp.
-	now func() time.Time
-	// seq numbers the report files, so that two named in the same
-	// millisecond still get different names.
-	seq      atomic.Uint64
 	stopOnce sync.Once
 	// usedBytes is what Append checks against maxBytes: the size
 	// of the report files in dataDir, plus the reports not yet
@@ -87,7 +79,6 @@ func New(
 		done:     make(chan struct{}),
 		log:      params.Logger.Get(),
 		maxBytes: params.Config.DataDirMaxBytes,
-		now:      time.Now,
 	}
 
 	lc.Append(fx.Hook{
@@ -220,14 +211,11 @@ func (b *Buffer) drainBuf() []byte {
 // writeFile creates a timestamped zstd-compressed JSONL file
 // in the data directory.
 func (b *Buffer) writeFile(data []byte) error {
-	// The timestamp comes first, so the names sort by time; the number
+	ts := time.Now().UTC().Format("2006-01-02T15-04-05.000Z")
-	// after it tells apart files named in the same millisecond.
+	path := filepath.Join(b.dataDir, filePrefix+ts+fileSuffix)
-	ts := b.now().UTC().Format("2006-01-02T15-04-05.000Z")
-	name := fmt.Sprintf("%s%s-%d%s", filePrefix, ts, b.seq.Add(1), fileSuffix)
-	path := filepath.Join(b.dataDir, name)
 
 	// path is built from the operator-supplied dataDir plus a
-	// generated timestamp and number, so it carries no external input.
+	// generated timestamp, so it carries no external input.
 	f, err := os.OpenFile( //nolint:gosec // see comment above
 		path,
 		os.O_WRONLY|os.O_CREATE|os.O_EXCL,

backend/internal/reportbuf/reportbuf_test.go

@@ -3,24 +3,18 @@ package reportbuf_test
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io/fs"
 	"os"
 	"path/filepath"
-	"slices"
 	"strconv"
 	"strings"
-	"sync"
-	"sync/atomic"
 	"testing"
-	"time"
 
 	"sneak.berlin/go/netwatch/internal/config"
 	"sneak.berlin/go/netwatch/internal/globals"
 	"sneak.berlin/go/netwatch/internal/logger"
 	"sneak.berlin/go/netwatch/internal/reportbuf"
 
-	"github.com/klauspost/compress/zstd"
 	"go.uber.org/fx"
 	"go.uber.org/fx/fxtest"
 )
@@ -219,194 +213,6 @@ func TestWrittenReportsCountAtFileSize(t *testing.T) {
 	}
 }
 
-// TestWrittenReportsKeepCounting writes one report file after another
-// under a small cap: each report must be taken while the files on disk
-// leave room for it, and refused once they do not.
-func TestWrittenReportsKeepCounting(t *testing.T) {
-	const maxBytes = 200
-
-	report := map[string]string{"id": "written"}
-	size := int64(lineBytes(t, report))
-	dir := t.TempDir()
-
-	t.Setenv("DATA_DIR", dir)
-	t.Setenv("DATA_DIR_MAX_BYTES", strconv.Itoa(maxBytes))
-
-	buf := startBuffer(t)
-
-	// Every file takes at least a byte, so they fill the cap within
-	// maxBytes rounds.
-	for range maxBytes {
-		used := reportFilesBytes(t, dir)
-
-		err := buf.Append(report)
-		if used+size > maxBytes {
-			if !errors.Is(err, reportbuf.ErrFull) {
-				t.Fatalf("with %d bytes of report files: error = %v, "+
-					"want ErrFull", used, err)
-			}
-
-			return
-		}
-
-		if err != nil {
-			t.Fatalf("with %d bytes of report files: %v", used, err)
-		}
-
-		err = buf.Flush()
-		if err != nil {
-			t.Fatalf("flush: %v", err)
-		}
-	}
-
-	t.Fatal("the report files never filled the cap")
-}
-
-// TestConcurrentAppendsStopAtCap appends from many goroutines at once
-// with room for exactly roomFor reports: exactly that many must be
-// taken, which holds only if Append checks and counts each report
-// under one lock.
-func TestConcurrentAppendsStopAtCap(t *testing.T) {
-	const (
-		roomFor = 5
-		senders = 50
-	)
-
-	// Large, so each Append takes long enough for the senders to
-	// overlap while the cap is reached.
-	report := map[string]string{"id": strings.Repeat("a", 1_000_000)}
-
-	t.Setenv("DATA_DIR", t.TempDir())
-	t.Setenv("DATA_DIR_MAX_BYTES",
-		strconv.Itoa(roomFor*lineBytes(t, report)))
-
-	buf := startBuffer(t)
-
-	var (
-		taken atomic.Int64
-		wg    sync.WaitGroup
-	)
-
-	start := make(chan struct{})
-
-	for range senders {
-		wg.Go(func() {
-			<-start
-
-			err := buf.Append(report)
-			if err == nil {
-				taken.Add(1)
-			} else if !errors.Is(err, reportbuf.ErrFull) {
-				t.Errorf("append: %v", err)
-			}
-		})
-	}
-
-	close(start)
-	wg.Wait()
-
-	if got := taken.Load(); got != roomFor {
-		t.Fatalf("%d reports taken, want %d", got, roomFor)
-	}
-}
-
-// TestTwoFlushesInOneMillisecond flushes twice within one millisecond,
-// as a flush for size and the final flush at shutdown can: each flush
-// must write a file of its own, and the files must hold every report.
-func TestTwoFlushesInOneMillisecond(t *testing.T) {
-	const flushes = 2
-
-	dir := t.TempDir()
-	t.Setenv("DATA_DIR", dir)
-
-	buf := startBuffer(t)
-	buf.StopClock(time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC))
-
-	for id := 1; id <= flushes; id++ {
-		err := buf.Append(map[string]int{"id": id})
-		if err != nil {
-			t.Fatalf("append report %d: %v", id, err)
-		}
-
-		err = buf.Flush()
-		if err != nil {
-			t.Fatalf("flush %d: %v", id, err)
-		}
-	}
-
-	files := readReportFiles(t, dir)
-	if len(files) != flushes {
-		t.Fatalf("%d report files after %d flushes", len(files), flushes)
-	}
-
-	for id := 1; id <= flushes; id++ {
-		want := fmt.Sprintf(`{"id":%d}`+"\n", id)
-		if !slices.Contains(files, want) {
-			t.Fatalf("no report file holds report %d alone", id)
-		}
-	}
-}
-
-// reportFilesBytes returns the total size of the report files in dir.
-func reportFilesBytes(t *testing.T, dir string) int64 {
-	t.Helper()
-
-	paths, err := filepath.Glob(filepath.Join(dir, "reports-*.jsonl.zst"))
-	if err != nil {
-		t.Fatalf("list report files: %v", err)
-	}
-
-	var total int64
-
-	for _, path := range paths {
-		info, statErr := os.Stat(path)
-		if statErr != nil {
-			t.Fatalf("stat %s: %v", path, statErr)
-		}
-
-		total += info.Size()
-	}
-
-	return total
-}
-
-// readReportFiles returns the decompressed contents of each report
-// file in dir.
-func readReportFiles(t *testing.T, dir string) []string {
-	t.Helper()
-
-	files := os.DirFS(dir)
-
-	names, err := fs.Glob(files, "reports-*.jsonl.zst")
-	if err != nil {
-		t.Fatalf("list report files: %v", err)
-	}
-
-	dec, err := zstd.NewReader(nil)
-	if err != nil {
-		t.Fatalf("create zstd decoder: %v", err)
-	}
-	defer dec.Close()
-
-	contents := make([]string, 0, len(names))
-
-	for _, name := range names {
-		compressed, readErr := fs.ReadFile(files, name)
-		if readErr != nil {
-			t.Fatalf("read %s: %v", name, readErr)
-		}
-
-		data, decErr := dec.DecodeAll(compressed, nil)
-		if decErr != nil {
-			t.Fatalf("decompress %s: %v", name, decErr)
-		}
-
-		contents = append(contents, string(data))
-	}
-
-	return contents
-}
-
 func writeBytes(t *testing.T, path string, n int) {
 	t.Helper()
 

backend/internal/server/routes_test.go

@@ -81,32 +81,6 @@ func TestReportsAreRateLimited(t *testing.T) {
 	}
 }
 
-// TestCORSAllowedOriginsReachTheRouter checks that an origin listed in
-// CORS_ALLOWED_ORIGINS is allowed by the router, not only when handed
-// to the CORS middleware directly.
-func TestCORSAllowedOriginsReachTheRouter(t *testing.T) {
-	const origin = "https://netwatch.example:8443"
-
-	t.Setenv("CORS_ALLOWED_ORIGINS", origin)
-
-	srv := newServer(t)
-	srv.SetupRoutes()
-
-	// The preflight a browser sends before it POSTs JSON from origin.
-	rec := httptest.NewRecorder()
-	req := httptest.NewRequestWithContext(t.Context(),
-		http.MethodOptions, "/api/v1/reports", http.NoBody)
-	req.Header.Set("Origin", origin)
-	req.Header.Set("Access-Control-Request-Method", http.MethodPost)
-	req.Header.Set("Access-Control-Request-Headers", "content-type")
-	srv.ServeHTTP(rec, req)
-
-	got := rec.Header().Get("Access-Control-Allow-Origin")
-	if got != origin {
-		t.Fatalf("Access-Control-Allow-Origin = %q, want %q", got, origin)
-	}
-}
-
 // TestHealthCheckRejectsOversizeBody sends the health check, which
 // never reads its body, a body one byte over the limit. Only the
 // router-wide body limit can reject it.

bin/entrypoint.sh

@@ -8,83 +8,23 @@
 # No set -e: kill and wait return non-zero here in normal operation.
 set -u
 
-# PORT is the public port nginx listens on, 8080 when unset or empty.
-# nginx would take a value such as localhost or unix:/tmp/x.sock as an
-# address and start anyway, and reports a bad port without naming
-# PORT, so a value that is not a usable port stops the container here,
-# before either process starts.
-export PORT="${PORT:-8080}"
-case "$PORT" in
-    *[!0-9]*)
-        echo "entrypoint: PORT must be a port number, not '$PORT'" >&2
-        exit 1
-        ;;
-esac
-# The length is checked first because, for a number too big for it,
-# the shell's test prints an error and is false, so the range checks
-# alone would let it through.
-if [ "${#PORT}" -gt 5 ] || [ "$PORT" -lt 1 ] || [ "$PORT" -gt 65535 ]; then
-    echo "entrypoint: PORT must be from 1 to 65535, not '$PORT'" >&2
-    exit 1
-fi
-if [ "$PORT" -eq 8081 ]; then
-    echo "entrypoint: PORT cannot be 8081, netwatch-server listens there" >&2
-    exit 1
-fi
-
-# TRUSTED_PROXIES names the reverse proxies in front of the container,
-# as IP addresses or CIDRs separated by commas. nginx takes the client
-# address from X-Forwarded-For only on a request from one of them, so
-# unset or empty, it trusts no one. nginx.conf includes the file written
-# here, one set_real_ip_from line per entry.
-#
-# nginx looks up an entry it cannot read as an address as a hostname,
-# and trusts what it finds (1.2.3 is found as 1.2.0.3). So each entry
-# is made a CIDR, a lone address getting /128 if it is IPv6 and /32 if
-# not, and netwatch-server checks it with the parsing it gives its own
-# TRUSTED_PROXIES. Its error, naming the CIDR, is dropped for the one
-# below, naming the entry as written. set -f keeps a * in an entry from
-# becoming a list of file names.
-TRUSTED_PROXIES="${TRUSTED_PROXIES:-}"
-set -f
-for proxy in $(printf '%s' "$TRUSTED_PROXIES" | tr ',' ' '); do
-    case "$proxy" in
-        */*) cidr="$proxy" ;;
-        *:*) cidr="$proxy/128" ;;
-        *) cidr="$proxy/32" ;;
-    esac
-    if ! netwatch-server check-cidr "$cidr" 2> /dev/null; then
-        echo "entrypoint: TRUSTED_PROXIES must be IP addresses or CIDRs" \
-            "separated by commas; '$proxy' is neither" >&2
-        exit 1
-    fi
-    echo "set_real_ip_from $cidr;"
-done > /etc/nginx/trusted-proxies.conf
-
 # A stop signal is only noted here; the loop below acts on it.
 stop_requested=""
 trap 'stop_requested=yes' TERM INT
 
 # netwatch-server runs as the netwatch user and listens on loopback
 # only, on a port other than the public one; nginx.conf proxies to this
-# address. Its only client is nginx, so it takes the client address
+# address. The netwatch user has no login shell, hence -s /bin/sh.
-# nginx passes on from 127.0.0.1 alone, whatever TRUSTED_PROXIES the
+# busybox su replaces itself with the command instead of staying on as
-# container has. The netwatch user has no login shell, hence -s
+# its parent, so $! is the server's own PID.
-# /bin/sh. busybox su replaces itself with the command instead of
+BIND_ADDRESS=127.0.0.1 PORT=8081 \
-# staying on as its parent, so $! is the server's own PID.
-BIND_ADDRESS=127.0.0.1 PORT=8081 TRUSTED_PROXIES=127.0.0.1/32 \
     su -s /bin/sh netwatch -c 'exec netwatch-server' &
 backend=$!
 
 # nginx starts through the nginx image's own entrypoint, which applies
 # the image's start-up configuration and then replaces itself with
-# nginx. Part of that start-up configuration renders nginx.conf into
+# nginx.
-# conf.d with nginx listening on PORT. NGINX_ENVSUBST_FILTER limits
+/docker-entrypoint.sh nginx -g 'daemon off;' &
-# that rendering to PORT: a variable nginx itself uses, such as $uri,
-# would otherwise be replaced by an environment variable of the same
-# name.
-NGINX_ENVSUBST_FILTER='^PORT$' \
-    /docker-entrypoint.sh nginx -g 'daemon off;' &
 nginx=$!
 
 running() {

nginx.conf

@@ -1,27 +1,14 @@
-# A template: the nginx image renders it into conf.d at container start,
-# filling in PORT and nothing else. bin/entrypoint.sh sets PORT and that
-# limit.
 server {
-    listen ${PORT};
+    listen 8080;
     server_name _;
 
-    # Keep the nginx version out of the Server header and error pages.
-    server_tokens off;
-
-    # The security headers, on every response. An add_header in a
-    # location drops every add_header from here, so a location with one
-    # of its own includes this file again.
-    include /etc/nginx/security-headers.conf;
-
     root /usr/share/nginx/html;
     index index.html;
 
-    # The client address comes from X-Forwarded-For only on a request
+    # Trust RFC1918 reverse proxies for X-Forwarded-For
-    # from the reverse proxies in TRUSTED_PROXIES: bin/entrypoint.sh
+    set_real_ip_from 10.0.0.0/8;
-    # writes one set_real_ip_from line for each into this file, and
+    set_real_ip_from 172.16.0.0/12;
-    # leaves it empty when TRUSTED_PROXIES is unset, so that by default
+    set_real_ip_from 192.168.0.0/16;
-    # the client address is the one each request comes from.
-    include /etc/nginx/trusted-proxies.conf;
     real_ip_header X-Forwarded-For;
     real_ip_recursive on;
 
@@ -37,7 +24,6 @@ server {
     location /assets/ {
         expires 1y;
         add_header Cache-Control "public, immutable";
-        include /etc/nginx/security-headers.conf;
     }
 
     # netwatch-server, the Go backend, runs in the same container and
@@ -51,16 +37,6 @@ server {
     proxy_set_header X-Forwarded-For $remote_addr;
     proxy_set_header X-Forwarded-Proto $scheme;
 
-    # netwatch-server sets the same security headers on its own
-    # responses. Its copies are dropped so that each header goes out
-    # once, as security-headers.conf sets it.
-    proxy_hide_header Strict-Transport-Security;
-    proxy_hide_header Content-Security-Policy;
-    proxy_hide_header X-Frame-Options;
-    proxy_hide_header X-Content-Type-Options;
-    proxy_hide_header Referrer-Policy;
-    proxy_hide_header Permissions-Policy;
-
     location /api/ {
         proxy_pass http://127.0.0.1:8081;
     }

script/frontend-viewport-test

@@ -61,18 +61,10 @@ main() {
     # host.
     docker network create --internal "$NETWORK" > /dev/null
 
-    # nginx.conf is a template: the image renders it over its own
-    # default.conf, with the same port and limit bin/entrypoint.sh uses.
-    # The empty file it includes trusts no proxy, as bin/entrypoint.sh
-    # writes it when TRUSTED_PROXIES is unset. nginx.conf also includes
-    # the security headers, so the page runs under the shipped policy.
     docker run -d --rm --name "$SERVER" \
         --network "$NETWORK" --network-alias netwatch \
-        -e PORT=8080 -e NGINX_ENVSUBST_FILTER='^PORT$' \
         -v "$ROOT/dist:/usr/share/nginx/html:ro" \
-        -v "$ROOT/nginx.conf:/etc/nginx/templates/default.conf.template:ro" \
+        -v "$ROOT/nginx.conf:/etc/nginx/conf.d/default.conf:ro" \
-        -v /dev/null:/etc/nginx/trusted-proxies.conf:ro \
-        -v "$ROOT/security-headers.conf:/etc/nginx/security-headers.conf:ro" \
         "$SERVER_IMAGE" > /dev/null
 
     # The image's own entrypoint already exposes CDP on 9222 and passes

security-headers.conf

@@ -1,24 +0,0 @@
-# The security headers REPO_POLICIES.md requires on every response.
-# nginx.conf includes this file, which Dockerfile copies to
-# /etc/nginx/security-headers.conf. always sends each header on error
-# responses too.
-
-add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
-
-# Scripts and styles load only from the page's own origin. Inline ones
-# are blocked, style attributes in markup included, so style elements
-# through classes or element.style. data: images are for the favicon
-# in index.html. connect-src is * because the browser checks each probe in
-# src/main.js against it, and also every redirect the probe follows,
-# and several of those hosts redirect to others; a list of hosts here
-# would block those probes. It also covers the reports the page sends
-# to its own origin.
-add_header Content-Security-Policy "default-src 'self'; connect-src *; img-src 'self' data:; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'" always;
-
-add_header X-Frame-Options DENY always;
-add_header X-Content-Type-Options nosniff always;
-
-# The probed hosts are not told where the page is served from.
-add_header Referrer-Policy no-referrer always;
-
-add_header Permissions-Policy "accelerometer=(), camera=(), display-capture=(), geolocation=(), gyroscope=(), magnetometer=(), microphone=(), midi=(), payment=(), usb=()" always;

src/main.js

@@ -716,7 +716,7 @@ function hostRowHTML(host, index, showPin = true) {
         ${pinBtn}
         <div class="w-[420px] flex-shrink-0 grid grid-cols-[minmax(0,1fr)_auto] items-center">
           <div class="flex items-center gap-2 min-w-[200px]">
-            <div class="w-3 h-3 rounded-full flex-shrink-0 bg-[#6b7280]"></div>
+            <div class="w-3 h-3 rounded-full flex-shrink-0" style="background-color: ${latencyHex(null)}"></div>
             <span class="font-medium text-white truncate">${host.name}</span>
           </div>
           <div class="latency-value text-4xl font-bold tabular-nums text-right mt-3" data-host="${index}">