check / check (push) Failing after 1m47s
It decides whether a request skips the wait for GeoJS, and only startLookUp calls it. It is not question or report code, so in questionsandreports.go the file's name did not say what it held. Model: opus-5-5
236 lines
6.7 KiB
Go
236 lines
6.7 KiB
Go
package waf
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"sneak.berlin/go/smallwebwaf/internal/requestlog"
|
|
"sneak.berlin/go/smallwebwaf/internal/wafprotocol"
|
|
)
|
|
|
|
// answerQuestion runs the checks on the visitor's request a question
|
|
// carries, and answers rproxy what to do with it. A denied request's counting
|
|
// is finished here, and an allowed one's by its report.
|
|
func (h *handler) answerQuestion(w http.ResponseWriter, r *http.Request) {
|
|
question, ok := h.readQuestion(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
rq := h.startRequest(
|
|
w,
|
|
question.Visitor,
|
|
question.Client,
|
|
question.Peer,
|
|
true,
|
|
)
|
|
// 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
|
|
refused := rq.check(r.Context())
|
|
rq.checked = time.Now()
|
|
underOwnPrefix := strings.HasPrefix(
|
|
r.URL.Path,
|
|
wafprotocol.OwnEndpointPrefix,
|
|
)
|
|
|
|
if refused == nil && !underOwnPrefix {
|
|
rq.allow()
|
|
// In observe mode, what enforce mode would have refused counts here.
|
|
rq.runBanningHeuristics(r.Context(), rq.h.afterAnswer)
|
|
|
|
return
|
|
}
|
|
|
|
if refused != nil {
|
|
rq.deny(*refused)
|
|
} 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
|
|
wafprotocol.SetAnswerHeaders(
|
|
rq.out.Header(),
|
|
wafprotocol.Answer{Disposition: wafprotocol.DispositionDeny},
|
|
)
|
|
http.Error(
|
|
rq.out,
|
|
http.StatusText(http.StatusNotFound),
|
|
http.StatusNotFound,
|
|
)
|
|
}
|
|
|
|
rq.banAndCount(r.Context(), rq.h.afterAnswer)
|
|
}
|
|
|
|
// readQuestion reads a question, and reports whether waf takes it. It answers
|
|
// a question it does not take with 400 and no disposition. rproxy passes that
|
|
// 400 to the visitor, and SWW_RPROXY_WAF_BACKEND_NO_ANSWER_DISPOSITION does
|
|
// not apply. The id of a question waf takes is held from here on, without a
|
|
// decision yet, so that another question with that id is refused while this
|
|
// one is being handled.
|
|
//
|
|
// A question whose body stops arriving gets no answer, and is not looked at.
|
|
func (h *handler) readQuestion(
|
|
w http.ResponseWriter, r *http.Request,
|
|
) (wafprotocol.Question, bool) {
|
|
question, err := wafprotocol.ReadQuestion(w, r)
|
|
if errors.Is(err, wafprotocol.ErrBodyStoppedArriving) {
|
|
h.processLog.Warn(
|
|
"a question's body stopped arriving",
|
|
"error",
|
|
err.Error(),
|
|
)
|
|
// This panic has Go's server close the connection without an answer,
|
|
// and log nothing.
|
|
panic(http.ErrAbortHandler)
|
|
}
|
|
|
|
if err != nil {
|
|
h.refuseQuestion(w, err.Error())
|
|
|
|
return question, false
|
|
}
|
|
|
|
held, _ := h.awaitingReport.ContainsOrAdd(question.RequestID, nil)
|
|
if held {
|
|
h.refuseQuestion(
|
|
w,
|
|
wafprotocol.RequestIDHeader+" is the id of a request waf holds",
|
|
)
|
|
|
|
return question, false
|
|
}
|
|
|
|
return question, true
|
|
}
|
|
|
|
// refuseQuestion answers a question waf does not take, for reason.
|
|
func (h *handler) refuseQuestion(w http.ResponseWriter, reason string) {
|
|
h.processLog.Warn("a question is refused", "reason", reason)
|
|
http.Error(w, reason, http.StatusBadRequest)
|
|
}
|
|
|
|
// allow answers a question with wafprotocol.DispositionAllow and, while
|
|
// SWW_WAF_ADD_LOOKUP_HEADERS is true, the client's AS number and country.
|
|
func (rq *request) allow() {
|
|
rq.allowed = true
|
|
|
|
answer := wafprotocol.Answer{Disposition: wafprotocol.DispositionAllow}
|
|
if rq.h.config.AddLookupHeaders {
|
|
answer.ASN = rq.lookupAnswer.ASN
|
|
answer.Country = rq.lookupAnswer.Country
|
|
}
|
|
|
|
wafprotocol.SetAnswerHeaders(rq.out.Header(), answer)
|
|
rq.out.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
// holdForReport holds a copy of what the report's steps need, by the request's
|
|
// id. A report only ever reaches that copy, never the request being handled.
|
|
func (rq *request) holdForReport() {
|
|
held := rq.decision
|
|
rq.h.awaitingReport.Add(rq.line.RequestID, &held)
|
|
}
|
|
|
|
// deny answers a question with what the visitor is to get for r.
|
|
func (rq *request) deny(r refusal) {
|
|
rq.refused = &r
|
|
|
|
if r.status == 0 {
|
|
// SWW_WAF_BAN_RESPONSE is close. Written past rq.out, since the log line's
|
|
// status stays 0: the visitor is sent nothing.
|
|
wafprotocol.SetAnswerHeaders(
|
|
rq.out.Header(),
|
|
wafprotocol.Answer{Disposition: wafprotocol.DispositionClose},
|
|
)
|
|
rq.out.ResponseWriter.WriteHeader(http.StatusOK)
|
|
|
|
return
|
|
}
|
|
|
|
wafprotocol.SetAnswerHeaders(
|
|
rq.out.Header(),
|
|
wafprotocol.Answer{Disposition: wafprotocol.DispositionDeny},
|
|
)
|
|
http.Error(rq.out, http.StatusText(r.status), r.status)
|
|
}
|
|
|
|
// handleReport answers POST wafprotocol.ReportPath: it finishes the request
|
|
// the report names, if it holds that request's decision, and ignores the
|
|
// report otherwise.
|
|
func (h *handler) handleReport() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
report, err := wafprotocol.ReadReport(w, r)
|
|
if err != nil {
|
|
h.processLog.Warn("a report is refused", "error", err.Error())
|
|
http.Error(w, "the body is not a report", http.StatusBadRequest)
|
|
|
|
return
|
|
}
|
|
|
|
held, found := h.awaitingReport.Peek(report.RequestID)
|
|
// Remove reports true to one report only, of several that name the
|
|
// id. A question still being handled is held as nil.
|
|
if found && held != nil &&
|
|
h.awaitingReport.Remove(report.RequestID) {
|
|
h.finishWith(r.Context(), held, report)
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
}
|
|
|
|
// finishWith finishes a request with what its report says, and writes the
|
|
// request's last log line, which holds its decision's fields and the report's.
|
|
// For an allowed request it first runs the heuristics of onReport, and adds the
|
|
// request to its client's history, the anomaly counters and the metrics, with
|
|
// the status and bytes the report gives. A denied request's counting was
|
|
// finished at its decision. ctx is the report's own context.
|
|
func (h *handler) finishWith(
|
|
ctx context.Context,
|
|
held *decision,
|
|
report wafprotocol.Report,
|
|
) {
|
|
rq := &request{
|
|
decision: *held,
|
|
h: h,
|
|
out: &responseWriter{
|
|
status: report.Status,
|
|
bytes: report.ResponseBytes,
|
|
},
|
|
requestBytes: report.RequestBytes,
|
|
}
|
|
|
|
rq.line.WAFLine = requestlog.WAFLineReport
|
|
rq.line.Status = report.Status
|
|
rq.line.RequestBytes = report.RequestBytes
|
|
rq.line.ResponseBytes = report.ResponseBytes
|
|
rq.line.DurationTotalMS = report.DurationTotalMS
|
|
|
|
if rq.allowed {
|
|
rq.line.DurationUpstreamTotalMS = &report.DurationUpstreamTotalMS
|
|
|
|
rq.banAndCount(ctx, rq.h.onReport)
|
|
|
|
rq.h.metrics.RequestReported(
|
|
&rq.line,
|
|
time.Duration(report.DurationTotalMS*float64(time.Millisecond)),
|
|
time.Duration(
|
|
report.DurationUpstreamTotalMS*float64(time.Millisecond),
|
|
),
|
|
)
|
|
}
|
|
|
|
rq.writeLine()
|
|
}
|