Bound every slog line against client-chosen text (closes #176)

MaxBodySize logged r.URL.Path untruncated at WARN, and routes.go
registers it ahead of RequireAuth, so an unauthenticated
POST /source/<8 KB>/edit with an oversize declared Content-Length wrote
attacker-chosen text of attacker-chosen length into the operator's log,
for the cost of a request with no body. The 2,560-byte per-line budget
#146 established did not reach it: that budget lives in the access-log
field capping and this is a separate slog call.

The capping mechanism moves out of internal/middleware into
internal/logfield so there is one budget and one implementation rather
than a second ad-hoc truncation. Truncate and EncodedBytes are
unchanged; the access log now spends logfield.MaxBytes where it spent
maxLogFieldBytes.

The sweep the issue asked for found five more call sites of the same
shape, all reachable unauthenticated, all now capped: the CSRF 403
(also registered ahead of RequireAuth), the rate limiters' 429 (the
per-entrypoint receiver limiter is unauthenticated), RequireAuth's own
DEBUG line, the unknown-entrypoint DEBUG line on the receiver, and the
failed-login DEBUG lines. DEBUG being off by default is not a bound: an
operator turning it on to diagnose a flood must not thereby hand the
flood an unbounded write. Every other slog call in the tree was read
and judged; the PR body lists all of them, including the ones left
alone and why.

MaxBodySize stays ahead of RequireAuth. An oversize body should be
refused before the request buys a cookie decrypt and a session load,
and rejecting first is what keeps an unauthenticated flood from
choosing how much session work the process does. The ordering and what
it costs are now written at the registration, on maxFormBodySize.

MaxAccessLogLineBytes is restated as the ceiling on every slog line
carrying a client-supplied value, not just the access log's: each of
these lines carries strictly fewer client-supplied fields than the
access log does, so none can be wider. That is asserted per line under
both handlers rather than argued. Two writers are called out as NOT
covered, so the figure is not read as more than it is: the log delivery
target, which exists to emit the whole event and is deliberate, and
GORM's default logger, which prints the interpolated SQL to stdout on a
record-not-found and is unbounded on the receiver and login lookups.
That second one is a real defect this audit turned up and is filed
separately as #178, not fixed here.

Tests drive 8 KB of client-chosen text at all six sites, through both
handlers internal/logger can install and through each character they
escape — including a bare C0 control, which costs six bytes on the line
against the one it cost to send and is the case a raw-byte budget
breaks on first. Each holds the encoded line to the ceiling, holds the
whole flood's output to what that ceiling allows, and asserts the
markers at the far end of the input are absent, so a value that merely
happened to be short cannot pass. internal/logfield gains a test that
measures the per-rune charge against what the handlers really emit over
roughly 3,000 code points on each, so an undercharged rune fails a test
instead of quietly falsifying the ceiling.

Verified by mutation: reverting the MaxBodySize cap alone fails 12
subtests with a 16,583-byte line against the 2,560 ceiling; reverting
the other five fails 70; budgeting raw bytes instead of encoded ones
fails 23 across three packages.

internal/handlers/logbound_test.go

@@ -0,0 +1,322 @@
+package handlers_test
+
+// The handler-side half of the log-field audit. Two slog calls in
+// this package reach a value an UNAUTHENTICATED client picks outright
+// and of a length it picks outright:
+//
+//   - the unknown-entrypoint DEBUG line on /webhook/{uuid}, whose
+//     path segment matched no stored entrypoint and so is bounded by
+//     nothing;
+//   - the failed-login DEBUG lines, whose username is a form field.
+//
+// Both are at DEBUG, which is off in production by default. That is
+// not a bound: an operator turning DEBUG on to diagnose a flood must
+// not thereby hand the flood an unbounded write. Both spend the same
+// internal/logfield budget as the access log, and both are held here
+// to middleware.MaxAccessLogLineBytes.
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/go-chi/chi"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/webhooker/internal/handlers"
+	"sneak.berlin/go/webhooker/internal/middleware"
+)
+
+// floodRequests is the number of distinct invented values each flood
+// drives through the call site under test.
+const floodRequests = 32
+
+// oversizedFillBytes is the length of the single client-chosen value
+// used to show that line size does not track input size.
+const oversizedFillBytes = 8192
+
+// attackerMarker and tailMarker sit at the END of every oversized
+// value, past every budget. Their absence from the log is what
+// proves the value was cut rather than merely being short.
+const (
+	attackerMarker = "QQATTACKERTEXTQQ"
+	tailMarker     = "QQTRUNCATEDTAILQQ"
+)
+
+// escapeFills are the characters the log handlers escape, so a value
+// built out of them costs more on the line than it did on the wire. A
+// budget counted in raw bytes passes the plain case and fails these.
+//
+// U+1000C is unassigned, hence non-printable, and strconv.Quote
+// spells it as a ten-byte \UXXXXXXXX while the JSON handler passes
+// its four UTF-8 bytes through; only the text shape of these tests
+// reaches that charge.
+func escapeFills() map[string]string {
+	return map[string]string{
+		"plain":     "x",
+		"quote":     `"`,
+		"backslash": `\`,
+		"tab":       "\t",
+		"newline":   "\n",
+		// A C0 control neither handler has a short escape for, so
+		// each one costs six bytes on the line against the single
+		// byte it cost to send: the widest multiplier a client can
+		// drive, and the case a raw-byte budget breaks on first.
+		"control": "\x01",
+		"astral":  "\U0001000C",
+	}
+}
+
+// logHandlers are the two handlers internal/logger can install.
+func logHandlers() map[string]func(
+	io.Writer, *slog.HandlerOptions,
+) slog.Handler {
+	return map[string]func(
+		io.Writer, *slog.HandlerOptions,
+	) slog.Handler{
+		"json": func(
+			w io.Writer, o *slog.HandlerOptions,
+		) slog.Handler {
+			return slog.NewJSONHandler(w, o)
+		},
+		"text": func(
+			w io.Writer, o *slog.HandlerOptions,
+		) slog.Handler {
+			return slog.NewTextHandler(w, o)
+		},
+	}
+}
+
+// oversizedFill builds an 8 KB client-chosen value out of
+// repetitions of ch, with both markers at its far end.
+func oversizedFill(ch string) string {
+	return "x" + strings.Repeat(ch, oversizedFillBytes) +
+		attackerMarker + tailMarker
+}
+
+// capturingHandlers builds a Handlers whose log is captured into the
+// returned buffer at DEBUG through the named handler.
+func capturingHandlers(
+	t *testing.T,
+	newHandler func(io.Writer, *slog.HandlerOptions) slog.Handler,
+) (*handlers.Handlers, *bytes.Buffer) {
+	t.Helper()
+
+	var h *handlers.Handlers
+
+	app := newTestApp(t, &h)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	buf := new(bytes.Buffer)
+	h.SetLogForTest(slog.New(newHandler(
+		buf, &slog.HandlerOptions{Level: slog.LevelDebug},
+	)))
+
+	return h, buf
+}
+
+// logLines splits the captured buffer into non-empty lines, holding
+// each to bound bytes.
+func logLines(t *testing.T, buf *bytes.Buffer, bound int) []string {
+	t.Helper()
+
+	var lines []string
+
+	for line := range strings.SplitSeq(
+		strings.TrimSpace(buf.String()), "\n",
+	) {
+		if line == "" {
+			continue
+		}
+
+		require.LessOrEqual(
+			t, len(line), bound,
+			"log line exceeded its bound: %s", line,
+		)
+
+		lines = append(lines, line)
+	}
+
+	return lines
+}
+
+// assertNoClientText fails if the far end of the client-chosen input
+// survived into the log.
+func assertNoClientText(t *testing.T, buf *bytes.Buffer) {
+	t.Helper()
+
+	assert.NotContains(
+		t, buf.String(), attackerMarker,
+		"log carried attacker-chosen text",
+	)
+	assert.NotContains(
+		t, buf.String(), tailMarker,
+		"log carried the tail of the attacker-chosen text",
+	)
+}
+
+// receiverRouter mounts the real receiver handler at the production
+// route pattern.
+func receiverRouter(h *handlers.Handlers) *chi.Mux {
+	router := chi.NewRouter()
+	router.Post("/webhook/{uuid}", h.HandleWebhook())
+
+	return router
+}
+
+// postReceiver sends one POST at /webhook/<segment>.
+//
+// RawPath is cleared after parsing so chi routes on the decoded path
+// and the handler sees the raw bytes rather than their percent-escaped
+// spelling. That is the harder case for the budget: the escaped
+// spelling is plain ASCII, which costs one byte per byte, while the
+// decoded bytes are what the log handler has to escape.
+func postReceiver(
+	t *testing.T, router *chi.Mux, segment string,
+) int {
+	t.Helper()
+
+	req := httptest.NewRequestWithContext(
+		context.Background(),
+		http.MethodPost,
+		"/webhook/"+url.PathEscape(segment),
+		strings.NewReader(""),
+	)
+	req.URL.RawPath = ""
+
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	return w.Code
+}
+
+// postLogin submits the login form with the given username and a
+// non-empty password.
+func postLogin(
+	t *testing.T, h *handlers.Handlers, username string,
+) int {
+	t.Helper()
+
+	form := url.Values{
+		"username": {username},
+		"password": {"not-the-password"},
+	}
+
+	req := httptest.NewRequestWithContext(
+		context.Background(),
+		http.MethodPost,
+		"/pages/login",
+		strings.NewReader(form.Encode()),
+	)
+	req.Header.Set(
+		"Content-Type", "application/x-www-form-urlencoded",
+	)
+
+	w := httptest.NewRecorder()
+	h.HandleLoginSubmit().ServeHTTP(w, req)
+
+	return w.Code
+}
+
+// TestUnknownEntrypoint_LogLineDoesNotTrackPathSize drives 8 KB of
+// client-chosen path at the unauthenticated receiver's
+// unknown-entrypoint DEBUG line and holds it to the same ceiling the
+// access log states.
+func TestUnknownEntrypoint_LogLineDoesNotTrackPathSize(t *testing.T) {
+	t.Parallel()
+
+	for handlerName, newHandler := range logHandlers() {
+		for fillName, fill := range escapeFills() {
+			t.Run(handlerName+"/"+fillName, func(t *testing.T) {
+				t.Parallel()
+
+				h, buf := capturingHandlers(t, newHandler)
+				router := receiverRouter(h)
+
+				for i := range floodRequests {
+					assert.Equal(
+						t,
+						http.StatusNotFound,
+						postReceiver(
+							t, router,
+							oversizedFill(fill)+
+								strings.Repeat("y", i),
+						),
+					)
+				}
+
+				lines := logLines(
+					t, buf, middleware.MaxAccessLogLineBytes,
+				)
+				require.Len(t, lines, floodRequests)
+				assertNoClientText(t, buf)
+
+				assertBoundedFlood(t, buf.Len())
+			})
+		}
+	}
+}
+
+// TestFailedLogin_LogLineDoesNotTrackUsernameSize drives 8 KB of
+// client-chosen username at the unauthenticated login endpoint's
+// DEBUG line and holds it to the same ceiling.
+func TestFailedLogin_LogLineDoesNotTrackUsernameSize(t *testing.T) {
+	t.Parallel()
+
+	for handlerName, newHandler := range logHandlers() {
+		for fillName, fill := range escapeFills() {
+			t.Run(handlerName+"/"+fillName, func(t *testing.T) {
+				t.Parallel()
+
+				h, buf := capturingHandlers(t, newHandler)
+
+				for i := range floodRequests {
+					assert.Equal(
+						t,
+						http.StatusUnauthorized,
+						postLogin(
+							t, h,
+							oversizedFill(fill)+
+								strings.Repeat("y", i),
+						),
+					)
+				}
+
+				lines := logLines(
+					t, buf, middleware.MaxAccessLogLineBytes,
+				)
+				require.Len(t, lines, floodRequests)
+				assertNoClientText(t, buf)
+
+				assertBoundedFlood(t, buf.Len())
+			})
+		}
+	}
+}
+
+// assertBoundedFlood holds the whole flood's log output to what the
+// stated per-line ceiling allows. The flood sent
+// floodRequests * oversizedFillBytes bytes of client-chosen text;
+// this is the assertion that the log did not grow with it.
+func assertBoundedFlood(t *testing.T, got int) {
+	t.Helper()
+
+	sent := floodRequests * oversizedFillBytes
+
+	require.Less(
+		t, got, sent/2,
+		"log volume tracked the size of the flood's input",
+	)
+	require.LessOrEqual(
+		t, got,
+		floodRequests*middleware.MaxAccessLogLineBytes,
+	)
+}