waf: one Cookie line, and a 500 ms GeoJS wait (closes #401)
check / check (push) Failing after 14m7s

A browser sends all its cookies on one Cookie line (RFC 6265), and Go's
server joins HTTP/2 Cookie lines into one, so waf now refuses a second
line with 431. Further lines only gave a visitor more bytes for the Core
Rule Set to read. The refusal logs cookie_lines and cookie_lines_limit.

The default of SWW_WAF_ASN_AND_COUNTRY_LOOKUP_TIMEOUT_MS drops from 800
to 500 milliseconds, so the Core Rule Set's share of rproxy's 2 seconds
grows from 1 to 1.3 seconds. The slowest worst-case request takes about
0.84 seconds of processor time with every core busy.

Model: opus-5-5
This commit is contained in:
clawbot authored and sneak committed 2026-11-16 22:15:13 +00:00
1 parent 988f117ef3
commit 01a8a7aa08
9 files changed
+68 -47

No files matched your search

+1 -1
View File
@@ -548,7 +548,7 @@ func WAFFromEnvironment(v *viper.Viper) (*WAF, error) {
LookupDBPath: env.value("SWW_WAF_LOOKUP_DB_PATH", ""),
ASNAndCountryLookupTimeout: env.milliseconds(
"SWW_WAF_ASN_AND_COUNTRY_LOOKUP_TIMEOUT_MS",
"800",
"500",
),
ExclusivelyAllowedCountries: env.countries(
"SWW_WAF_EXCLUSIVELY_ALLOWED_COUNTRIES", ""),
+3 -3
View File
@@ -286,7 +286,7 @@ func TestDefaults(t *testing.T) {
RuleFilesEnabled: true,
})
wantLookupSettings(t, cfg, config.WAF{
LookupSource: defaultLookupSource, ASNAndCountryLookupTimeout: 800 * time.Millisecond,
LookupSource: defaultLookupSource, ASNAndCountryLookupTimeout: 500 * time.Millisecond,
AddLookupHeaders: true,
})
wantByteLimitSettings(t, cfg, config.WAF{
@@ -1407,7 +1407,7 @@ func TestLookupSettingsAsSet(t *testing.T) {
// With no client looked up, the headers are off unless set.
cfg = wafFromEnvironment(t, environment{lookupSource: off})
wantLookupSettings(t, cfg, config.WAF{
LookupSource: off, ASNAndCountryLookupTimeout: 800 * time.Millisecond,
LookupSource: off, ASNAndCountryLookupTimeout: 500 * time.Millisecond,
})
}
@@ -2933,7 +2933,7 @@ func TestLogsEachSettingWithItsValue(t *testing.T) {
bytesCounted: "both",
lookupSource: defaultLookupSource,
lookupDBPath: "",
asnAndCountryLookupTimeout: "800",
asnAndCountryLookupTimeout: "500",
addLookupHeaders: enabled,
allowedCountries: "",
tagLists: "",
+18 -16
View File
@@ -35,20 +35,20 @@ const (
mostJSONRead = 1 << 10
)
// The Core Rule Set has 1 second for one request. That is the default of
// The Core Rule Set has 1.3 seconds for one request. That is the default of
// rproxy's SWW_RPROXY_WAF_BACKEND_TIMEOUT_MS, 2 seconds, less the default of
// SWW_WAF_ASN_AND_COUNTRY_LOOKUP_TIMEOUT_MS, 800 milliseconds, and less 200
// SWW_WAF_ASN_AND_COUNTRY_LOOKUP_TIMEOUT_MS, 500 milliseconds, and less 200
// milliseconds for waf's other checks.
//
// A busy host slows all work, so the test does not compare an inspection with
// 1 second. It compares it with referenceTime, timed on the same thread just
// before and after. inspectionTimeLimitMultiple is how many times
// 1.3 seconds. It compares it with referenceTime, timed on the same thread
// just before and after. inspectionTimeLimitMultiple is how many times
// referenceTime an inspection may take.
//
// On the host that runs our checks, referenceTime took at least 78
// milliseconds, so 13 times it is about 1 second. With that host fully busy,
// no try of the slowest request took more than 9.5 times referenceTime.
const inspectionTimeLimitMultiple = 13
// milliseconds, so 16 times it is about 1.25 seconds. With that host fully
// busy, no try of the slowest request took more than 6.7 times referenceTime.
const inspectionTimeLimitMultiple = 16
// referencePattern is what referenceTime matches. Like the Core Rule Set's
// rules, it is a regular expression with alternatives and repeats.
@@ -221,20 +221,22 @@ const fullLine = lineLimit - 64
// worstCaseRequests are, for each kind of thing a visitor sends, the requests
// that keep the Core Rule Set busiest, within the bounds above. The last
// holds the most of everything at once: Cookie lines keep it busier than
// other header lines, and the JSON body of the most elements under a key
// keeps it busier than the other bodies.
// holds the most of everything at once. waf refuses a second Cookie line, so
// it has one, and User-Agent and Referer lines, which keep the Core Rule Set
// busier than other header lines. The JSON body of the most elements under a
// key keeps it busier than the other bodies.
func worstCaseRequests() []visitorRequest {
fullCookieLine := cookieLine(1)[:fullLine-len("Cookie: ")]
return append(
append(worstCaseHeaders(), worstCaseBodies()...),
visitorRequest{
name: "the longest request line, three Cookie lines and body",
name: "the longest request line, Cookie, User-Agent and " +
"Referer lines and body",
target: longestTarget()[:fullLine-len("POST HTTP/1.1")],
header: http.Header{cookieHeader: {
fullCookieLine, fullCookieLine, fullCookieLine,
}},
header: http.Header{
cookieHeader: {cookieLine(1)[:fullLine-len("Cookie: ")]},
"User-Agent": {headerValue("User-Agent", fullLine)},
"Referer": {headerValue("Referer", fullLine)},
},
contentType: jsonType, body: jsonOfMostElementsUnderAKey(),
},
)
+8 -4
View File
@@ -33,7 +33,7 @@ const (
// SWW_RPROXY_WAF_BACKEND_TIMEOUT_MS, the time waf has to answer.
answerTimeLimit = 2 * time.Second
// defaultLookupWait is the default of SWW_WAF_ASN_AND_COUNTRY_LOOKUP_TIMEOUT_MS.
defaultLookupWait = 800 * time.Millisecond
defaultLookupWait = 500 * time.Millisecond
// defaultDNSBLAbuseIPDBWait is the default of SWW_WAF_DNSBL_ABUSEIPDB_TIMEOUT_MS.
defaultDNSBLAbuseIPDBWait = 2 * time.Second
// The header limits SPEC.md gives.
@@ -111,7 +111,8 @@ func TestHeaderLimitRefusalNamesItsHeuristicCountsAndLimits(t *testing.T) {
s.out.requestLine(t),
"header_limits",
`{"longest_header_line_bytes": 40, "header_line_bytes_limit": 8192,
"fields": 101, "fields_limit": 100, "cookies": 0, "cookies_limit": 50}`,
"fields": 101, "fields_limit": 100, "cookie_lines": 0,
"cookie_lines_limit": 1, "cookies": 0, "cookies_limit": 50}`,
)
}
@@ -198,6 +199,9 @@ func TestAHeaderLineOverTheLimitIsRefusedWith431(t *testing.T) {
{"a header line over the limit", func(req *http.Request) {
req.Header.Set("X-Long", strings.Repeat("a", lineLimit+1-len("X-Long: ")))
}, true},
{"a Cookie line at the limit", func(req *http.Request) {
req.Header.Set(cookieHeader, "a="+strings.Repeat("a", lineLimit-len("Cookie: a=")))
}, false},
{"one cookie over the limit", func(req *http.Request) {
req.Header.Set(cookieHeader, "a="+strings.Repeat("a", lineLimit))
}, true},
@@ -267,8 +271,8 @@ func TestEachHeaderLimitRefusesARequestOverIt(t *testing.T) {
{"parts of no-break spaces count", func(req *http.Request) {
req.Header.Set(cookieHeader, strings.Repeat(" ;", cookieLimit+1))
}, true},
{"cookies over the limit across two headers", func(req *http.Request) {
req.Header[cookieHeader] = []string{cookies(cookieLimit), "last=1"}
{"two Cookie lines", func(req *http.Request) {
req.Header[cookieHeader] = []string{"a=1", "b=1"}
}, true},
{"cookies without a value count", func(req *http.Request) {
req.Header.Set(cookieHeader, strings.Repeat("a;", cookieLimit+1))
+16 -9
View File
@@ -10,11 +10,15 @@ import (
"sneak.berlin/go/smallwebwaf/internal/requestlog"
)
// The header limits: the most cookies and header fields a request may have,
// and the longest its request line and each header line may be, in bytes, not
// counting the line ending. Real clients rarely reach them. maxLineBytes is
// what nginx allows by default.
// The header limits: the most Cookie lines, cookies and header fields a request
// may have, and the longest its request line and each header line may be, in
// bytes, not counting the line ending. Real clients rarely reach them.
// maxLineBytes is what nginx allows by default. A browser sends all its cookies
// on one Cookie line, as RFC 6265 requires, and Go's server joins the Cookie
// lines of an HTTP/2 request into one. A second line would only give a visitor
// another 8 KiB for the Core Rule Set to read.
const (
maxCookieLines = 1
maxCookies = 50
maxHeaderFields = 100
maxLineBytes = 8 << 10
@@ -22,10 +26,11 @@ const (
// headerLimits refuses a request with a request line longer than maxLineBytes,
// with 414. It refuses a request with a header line longer than maxLineBytes,
// more than maxHeaderFields header fields or more than maxCookies cookies, with
// 431. Its figures are the request line's length and its limit for 414. For
// 431 they are the longest header line, the header fields and the cookies,
// each with its limit.
// more than maxHeaderFields header fields, more than maxCookieLines Cookie
// lines or more than maxCookies cookies, with 431. Its figures are the request
// line's length and its limit for 414. For 431 they are the longest header
// line, the header fields, the Cookie lines and the cookies, each with its
// limit.
type headerLimits struct{}
func (headerLimits) name() string { return "header_limits" }
@@ -48,9 +53,10 @@ func (headerLimits) check(
longest := rq.longestHeaderLineBytes()
fields, cookies := rq.headerCounts()
cookieLines := len(rq.in.Header.Values("Cookie"))
if longest <= maxLineBytes && fields <= maxHeaderFields &&
cookies <= maxCookies {
cookieLines <= maxCookieLines && cookies <= maxCookies {
return nil
}
@@ -60,6 +66,7 @@ func (headerLimits) check(
"longest_header_line_bytes": longest,
"header_line_bytes_limit": maxLineBytes,
"fields": fields, "fields_limit": maxHeaderFields,
"cookie_lines": cookieLines, "cookie_lines_limit": maxCookieLines,
"cookies": cookies, "cookies_limit": maxCookies,
},
}