From d6002e282f5c5e0a89f63fb5468e5c44551f6a38 Mon Sep 17 00:00:00 2001 From: sneak Date: Thu, 19 Nov 2026 17:40:46 +0000 Subject: [PATCH] waf: the steps after the answer as plain statements (closes #445) banAndCount runs the heuristics that only ban, then countAnomalies, then addToHistory. A refused request's decision and an allowed request's report both call it, each with its own list. answerQuestion keeps one defer, which writes the log line and holds the decision for the report. A check that panics now leaves the request out of its client's history and the anomaly counts, as the issue states. Model: opus-5-5 --- internal/waf/heuristics.go | 6 ----- internal/waf/request.go | 10 ++++++++ internal/waf/waf.go | 49 ++++++++++++++++---------------------- 3 files changed, 31 insertions(+), 34 deletions(-) diff --git a/internal/waf/heuristics.go b/internal/waf/heuristics.go index 9fb7e59..89b7a24 100644 --- a/internal/waf/heuristics.go +++ b/internal/waf/heuristics.go @@ -104,12 +104,6 @@ func onReport() []heuristic { } } -// runAfterAnswer runs the heuristics of afterAnswer on the request, at the time -// it is called. -func (rq *request) runAfterAnswer(ctx context.Context) { - rq.runBanningHeuristics(ctx, afterAnswer()) -} - // runHeuristics runs list, one of those checkClient runs, on the request at now, // and returns the first verdict, or nil when none gives one. The log line's // heuristic and heuristic_figures name the heuristic that gave it, and give its diff --git a/internal/waf/request.go b/internal/waf/request.go index bc900aa..3657f5b 100644 --- a/internal/waf/request.go +++ b/internal/waf/request.go @@ -345,6 +345,16 @@ func timing(start, end time.Time) *float64 { return new(requestlog.Milliseconds(end.Sub(start))) } +// banAndCount runs list, afterAnswer or onReport, whose heuristics only ban. +// It then counts the request for the anomaly thresholds and adds it to its +// client's history. list runs first, so that a refusal limit it finds broken +// is in that history. ctx is the request's own context. +func (rq *request) banAndCount(ctx context.Context, list []heuristic) { + rq.runBanningHeuristics(ctx, list) + rq.countAnomalies() + rq.addToHistory() +} + // addToHistory adds the request, which has ended, to its client's // history, and counts its offences in the metrics, and then the lookup's // answer about the client, as answerAtTheEnd gives it, to that history and diff --git a/internal/waf/waf.go b/internal/waf/waf.go index ec8d9ea..b773903 100644 --- a/internal/waf/waf.go +++ b/internal/waf/waf.go @@ -177,11 +177,13 @@ func (h *handler) answerQuestion(w http.ResponseWriter, r *http.Request) { peer.Unmap(), true, ) - // The last deferred runs first, so that what is held has the finished log - // line. Go's server sends the answer only once this function has - // returned, so the report cannot come before it is held. - defer rq.holdForReport() - defer rq.finish() + // These run even when a check panics. finish runs first, so that what is + // held has the finished log line. Go's server sends the answer only once + // this function has returned, so the report cannot come before it is held. + defer func() { + rq.finish() + rq.holdForReport() + }() rq.site = r.Host rq.line.WAFLine = requestlog.WAFLineDecision @@ -190,35 +192,28 @@ func (h *handler) answerQuestion(w http.ResponseWriter, r *http.Request) { underOwnPrefix := strings.HasPrefix(r.URL.Path, ownEndpointPrefix) if refused == nil && !underOwnPrefix { - // In observe mode, what enforce mode would have refused counts here. - defer rq.runAfterAnswer(r.Context()) - rq.allow() + // In observe mode, what enforce mode would have refused counts here. + rq.runBanningHeuristics(r.Context(), afterAnswer()) return } - // The last deferred runs first: runAfterAnswer before addToHistory, so that - // a broken refusal limit is in the client's history. - defer rq.addToHistory() - defer rq.countAnomalies() - defer rq.runAfterAnswer(r.Context()) - if refused != nil { rq.deny(*refused) - - return + } else { + // The app never sees this prefix. waf's own endpoints are at its + // own address, so this answers as a path with no endpoint does. + rq.line.Action = requestlog.ActionOwnEndpoint + rq.out.Header().Set(DispositionHeader, DispositionDeny) + http.Error( + rq.out, + http.StatusText(http.StatusNotFound), + http.StatusNotFound, + ) } - // The app never sees this prefix. waf's own endpoints are at its - // own address, so this answers as a path with no endpoint does. - rq.line.Action = requestlog.ActionOwnEndpoint - rq.out.Header().Set(DispositionHeader, DispositionDeny) - http.Error( - rq.out, - http.StatusText(http.StatusNotFound), - http.StatusNotFound, - ) + rq.banAndCount(r.Context(), afterAnswer()) } // readQuestion returns the visitor's address and the body a question carries, @@ -491,9 +486,7 @@ func (h *handler) finishWith( if rq.allowed { rq.line.DurationUpstreamTotalMS = &report.DurationUpstreamTotalMS - rq.runBanningHeuristics(ctx, onReport()) - rq.countAnomalies() - rq.addToHistory() + rq.banAndCount(ctx, onReport()) rq.h.metrics.RequestReported( &rq.line, -- 2.54.0