Compare commits

..
Author SHA1 Message Date
sneak f6df989e67 coreruleset: time worst-case inspections in processor time
check / check (push) Failing after 2m9s
Not offered as a PR: processor time alone does not keep the test
from failing on a busy host. See the issue for the decision needed.

Model: opus-5-5
2026-11-16 07:13:40 +00:00
+22 -63
View File
@@ -5,7 +5,6 @@ import (
"net/http"
"net/http/httptest"
"net/netip"
"regexp"
"runtime"
"slices"
"strconv"
@@ -35,45 +34,12 @@ const (
mostJSONRead = 1 << 10
)
// The Core Rule Set has 1 second 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
// inspectionTimeLimit is the most time the Core Rule Set may take on one
// request. It 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, which a question can also wait for GeoJS, 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
// 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
// referencePattern is what referenceTime matches. Like the Core Rule Set's
// rules, it is a regular expression with alternatives and repeats.
var referencePattern = regexp.MustCompile(
`(?i)(union|select|insert|delete)\s+\w+\s+(from|into)\s+\w+[0-9]+;`,
)
// referenceTime returns the processor time the calling thread takes to do a
// fixed amount of work unrelated to the Core Rule Set, so that a change to the
// rules does not change it. referencePattern matches nowhere in the text, so
// each match reads all of it.
func referenceTime(t *testing.T) time.Duration {
t.Helper()
referenceText := text(4 << 10)
began := threadCPUTime(t)
for range 200 {
if referencePattern.MatchString(referenceText) {
t.Fatal("the reference pattern matched")
}
}
return threadCPUTime(t) - began
}
const inspectionTimeLimit = time.Second
// text returns n bytes of letters, digits and spaces, which the Core Rule Set
// takes longer over than one letter repeated.
@@ -353,16 +319,13 @@ func threadCPUTime(t *testing.T) time.Duration {
return time.Duration(now.Nano())
}
// inspectionTime returns the processor time crs takes to inspect tc, and the
// mean of referenceTime just before and after. It fails t unless crs reads all
// of tc's body and Coraza parses it.
//
// All of it runs on this goroutine, kept on one thread, so the thread's
// processor time measures it. Time other work holds the processor does not
// count.
// inspectionTime returns the processor time crs takes to inspect tc, and
// fails t unless it reads all of tc's body and Coraza parses it. Inspect does
// its work on the calling goroutine, which stays on one thread meanwhile, so
// that thread's processor time is the inspection's.
func inspectionTime(
t *testing.T, crs *coreruleset.CoreRuleSet, tc visitorRequest,
) (time.Duration, time.Duration) {
) time.Duration {
t.Helper()
req := httptest.NewRequestWithContext(
@@ -375,19 +338,14 @@ func inspectionTime(
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
before := referenceTime(t)
began := threadCPUTime(t)
result, read, _ := crs.Inspect(
req, netip.MustParseAddr("192.0.2.1"), strings.NewReader(tc.body),
)
took := threadCPUTime(t) - began
reference := (before + referenceTime(t)) / 2
if string(read) != tc.body {
t.Errorf("read %d bytes of %d", len(read), len(tc.body))
}
@@ -397,13 +355,15 @@ func inspectionTime(
t.Errorf("Coraza could not parse the body")
}
return took, reference
return took
}
// TestTheCoreRuleSetInspectsEachWorstCaseRequestInTime runs one at a time, so
// that the tests running in parallel do not slow it. Other work on the host
// can still slow one try more than the reference work around it, so a request
// fails only when three tries in a row take too long.
// TestTheCoreRuleSetInspectsEachWorstCaseRequestInTime measures processor
// time, not time on the clock, so that the time other work on the host holds
// the processor does not count. It runs one at a time, so that the tests
// running in parallel do not slow it. Other work can still slow one try a
// little, by sharing the processor's caches, so a request fails only when
// three tries in a row take too long.
//
//nolint:paralleltest // one at a time, as above
func TestTheCoreRuleSetInspectsEachWorstCaseRequestInTime(t *testing.T) {
@@ -417,19 +377,18 @@ func TestTheCoreRuleSetInspectsEachWorstCaseRequestInTime(t *testing.T) {
for _, tc := range worstCaseRequests() {
t.Run(tc.name, func(t *testing.T) {
var took, reference time.Duration
var took time.Duration
for range tries {
took, reference = inspectionTime(t, crs, tc)
if took <= inspectionTimeLimitMultiple*reference {
took = inspectionTime(t, crs, tc)
if took <= inspectionTimeLimit {
return
}
}
t.Errorf(
"took %s on the last of %d tries, over %d times the %s "+
"of the reference work",
took, tries, inspectionTimeLimitMultiple, reference,
"took %s on the last of %d tries, over %s",
took, tries, inspectionTimeLimit,
)
})
}