check / check (push) Successful in 3m54s
go.uber.org/fx builds the parts of waf and rproxy in internal/sww, one provider per part. Each background loop is a lifecycle hook added where its part is built. waf.Params takes every part built, and waf.New builds none. GeoJS calls back into waf, so waf exports AddLookup and GeoJSFailed, and clientGroup and banNetblock take the settings. newServer, loadStateFiles, the inBackground list and serveRProxy are gone. serve is the one hook that serves both daemons, and reports a failure to run on a channel of its own; fx's signal handling is not used. Once fx has stopped, run takes each daemon's last step: waf writes the state files, and rproxy waits for its reports. Model: opus-5-5
77 lines
2.4 KiB
Go
77 lines
2.4 KiB
Go
package waf
|
|
|
|
// The heuristic rate_limits. It reads SWW_WAF_RATE_LIMIT_EXEMPT_NETS,
|
|
// SWW_WAF_RATE_LIMIT_EXEMPT_PATHS and SWW_WAF_BAN_RESPONSE, and the rate limits and
|
|
// biased thresholds through the limiter and limitPercentages.
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"sneak.berlin/go/smallwebwaf/internal/requestlog"
|
|
)
|
|
|
|
// rateLimits counts the request for the rate limits, unless
|
|
// countedByRateLimits exempts it, by the client's limit percentages, which it
|
|
// notes for the log line with the client's counts. A request that takes the
|
|
// client over a rate limit, as its limit percentage lowers it, breaks it: it is
|
|
// refused, and bans the client. A request exempt from the rate limits is exempt
|
|
// from the byte limits too. Its figures are the window, the count and the
|
|
// limit.
|
|
type rateLimits struct{}
|
|
|
|
func (rateLimits) name() string { return "rate_limits" }
|
|
|
|
func (rateLimits) check(
|
|
_ context.Context,
|
|
rq *request,
|
|
now time.Time,
|
|
) *verdict {
|
|
rq.counted = rq.countedByRateLimits()
|
|
if !rq.counted {
|
|
return nil
|
|
}
|
|
|
|
rq.rateLimitPercent, rq.bytesLimitPercent = rq.limitPercentages()
|
|
rq.line.RateLimitPercent, rq.line.RateLimitPercentSetting =
|
|
rq.rateLimitPercent.logged()
|
|
rq.line.BytesLimitPercent, rq.line.BytesLimitPercentSetting =
|
|
rq.bytesLimitPercent.logged()
|
|
|
|
counts, hit, over := rq.h.limiter.Count(
|
|
clientGroup(rq.h.config, rq.client),
|
|
now,
|
|
rq.rateLimitPercent.percent,
|
|
)
|
|
rq.line.Counts = counts
|
|
|
|
if !over {
|
|
return nil
|
|
}
|
|
|
|
rq.banForLimit(now, hit, rq.h.config.BanResponse)
|
|
|
|
return &verdict{
|
|
action: requestlog.ActionClientIsRateLimited, figures: limitFigures(hit),
|
|
}
|
|
}
|
|
|
|
// overAWholeRateLimit reports whether the heuristic rate_limits will refuse the
|
|
// request at now, whatever its client's limit percentages: the rate limits
|
|
// count it, and one more request from its client takes it over a whole rate
|
|
// limit. It counts nothing.
|
|
func (rq *request) overAWholeRateLimit(now time.Time) bool {
|
|
return rq.countedByRateLimits() &&
|
|
rq.h.limiter.OverARateLimit(clientGroup(rq.h.config, rq.client), now)
|
|
}
|
|
|
|
// countedByRateLimits reports whether the rate limits count the request: its
|
|
// client is not in SWW_WAF_RATE_LIMIT_EXEMPT_NETS, and its path is not exempt
|
|
// under SWW_WAF_RATE_LIMIT_EXEMPT_PATHS.
|
|
func (rq *request) countedByRateLimits() bool {
|
|
cfg := rq.h.config
|
|
|
|
return !isInside(rq.client, cfg.RateLimitExemptNets) &&
|
|
!pathExempt(rq.in, cfg.RateLimitExemptPaths)
|
|
}
|