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
2 changed files with 26 additions and 91 deletions

No files matched your search

+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,
)
})
}
+4 -28
View File
@@ -1424,14 +1424,7 @@ func TestFiveFailedAsksKeepTheNextRequestFromAskingWAF(t *testing.T) {
failure(w, r)
},
)
nextID := make(chan string, 1)
app := startApp(t, func(w http.ResponseWriter, r *http.Request) {
if answering.Load() {
nextID <- r.Header.Get(requestIDHeader)
}
greet(w, r)
})
app := startApp(t, greet)
addr, out := startRProxy(
t,
standIn.URL,
@@ -1441,36 +1434,19 @@ func TestFiveFailedAsksKeepTheNextRequestFromAskingWAF(t *testing.T) {
},
)
// An ask can time out before it reaches the stand-in, so these
// may leave fewer than five questions, or leave some late.
for range 5 {
wantGreeting(t, get(t, addr, "/"))
}
// rproxy writes this line before it answers a request it kept
// from asking waf, so no wait is needed.
if out.has("the circuit breaker is open") {
t.Error("the circuit breaker opened before five asks failed")
standIn.question(t)
}
answering.Store(true)
wantGreeting(t, get(t, addr, "/"))
out.waitFor(t, "the circuit breaker is open")
// Had the next request asked waf, its question would have reached
// the stand-in before the request reached the app.
var id string
select {
case id = <-nextID:
default:
t.Fatal("the app did not get the next request")
}
for len(standIn.questions) > 0 {
asked := <-standIn.questions
if asked.header.Get(requestIDHeader) == id {
case <-standIn.questions:
t.Error("waf was asked, want it not to be")
}
case <-time.After(10 * pollInterval):
}
})
}