check / check (push) Failing after 2m12s
The rproxy package's tests and sww's startRProxyProcess give rproxy a minute for waf's answers unless a test sets SWW_RPROXY_WAF_BACKEND_TIMEOUT_MS. At the 2-second default, a slow host made rproxy drop questions and reports. TestMainRunsWAF runs waf with the Core Rule Set off. Main keeps waf's 500 ms limit for its checks, and under the race detector the Core Rule Set's inspection could pass it and get 503. Model: opus-5-5
299 lines
6.9 KiB
Go
299 lines
6.9 KiB
Go
package sww_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/rand"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
|
|
// The time zone database, so that the process TestMainRunsWAF starts
|
|
// finds the zone TZ names on any host.
|
|
_ "time/tzdata"
|
|
|
|
"sneak.berlin/go/smallwebwaf/internal/sww"
|
|
"sneak.berlin/go/smallwebwaf/internal/waf"
|
|
)
|
|
|
|
// commandForMain, while set in the environment, has this test binary run Main
|
|
// with the command it gives, in place of the tests, so that a test can run
|
|
// Main in a process of its own.
|
|
const commandForMain = "SWW_TEST_COMMAND"
|
|
|
|
func TestMain(m *testing.M) {
|
|
command, set := os.LookupEnv(commandForMain)
|
|
if !set {
|
|
os.Exit(m.Run())
|
|
}
|
|
|
|
os.Args = strings.Fields("sww " + command)
|
|
|
|
os.Exit(sww.Main(testVersion))
|
|
}
|
|
|
|
// startProcess starts cmd and returns a channel that gets its exit status. As
|
|
// the test ends, cmd is killed and the test waits for it to exit.
|
|
func startProcess(t *testing.T, cmd *exec.Cmd) <-chan int {
|
|
t.Helper()
|
|
|
|
err := cmd.Start()
|
|
if err != nil {
|
|
t.Fatalf("start: %v", err)
|
|
}
|
|
|
|
exited := make(chan int, 1)
|
|
waitReturned := make(chan struct{})
|
|
|
|
go func() {
|
|
_ = cmd.Wait()
|
|
exited <- cmd.ProcessState.ExitCode()
|
|
|
|
close(waitReturned)
|
|
}()
|
|
|
|
t.Cleanup(func() {
|
|
_ = cmd.Process.Kill()
|
|
|
|
<-waitReturned
|
|
})
|
|
|
|
return exited
|
|
}
|
|
|
|
func TestMainRunsWAF(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Kiritimati is 14 hours ahead of UTC; every time sww gives stays in UTC.
|
|
const zone = "Pacific/Kiritimati"
|
|
|
|
_, err := time.LoadLocation(zone)
|
|
if err != nil {
|
|
t.Fatalf("load %s: %v", zone, err)
|
|
}
|
|
|
|
binary, err := os.Executable()
|
|
if err != nil {
|
|
t.Fatalf("find the test binary: %v", err)
|
|
}
|
|
|
|
dir := t.TempDir()
|
|
out := &output{}
|
|
//nolint:gosec // this test binary
|
|
cmd := exec.CommandContext(t.Context(), binary)
|
|
cmd.Stdout = out
|
|
|
|
// The Core Rule Set is off. Main keeps waf's own limit for its checks,
|
|
// and on a busy host the Core Rule Set's inspection can pass it.
|
|
cmd.Env = append(os.Environ(),
|
|
"TZ="+zone,
|
|
commandForMain+"="+wafCommand,
|
|
listenAddr+"="+localhost+":0",
|
|
stateDir+"="+dir,
|
|
cacheDir+"="+dir,
|
|
ruleFilesDir+"="+t.TempDir(),
|
|
lookupSource+"=off",
|
|
"SWW_WAF_CORE_RULE_SET_MODE=off")
|
|
|
|
exited := startProcess(t, cmd)
|
|
|
|
starting := out.lineBeforeExit(t, "starting", exited)
|
|
addr, _ := starting["address"].(string)
|
|
ask(t, addr, "/", http.StatusOK, waf.DispositionAllow)
|
|
|
|
// The files are written as sww stops.
|
|
err = cmd.Process.Signal(syscall.SIGTERM)
|
|
if err != nil {
|
|
t.Fatalf("signal: %v", err)
|
|
}
|
|
|
|
select {
|
|
case status := <-exited:
|
|
if status != 0 {
|
|
t.Fatalf(
|
|
"exit status %d, want 0; output:\n%s",
|
|
status,
|
|
out.text(),
|
|
)
|
|
}
|
|
case <-time.After(waitLimit):
|
|
t.Fatal("still running after being told to stop")
|
|
}
|
|
|
|
wantUTC(t, "the process line", starting["time"])
|
|
wantUTC(t, "the request line", out.line(t, "type", "request")["time"])
|
|
|
|
path := filepath.Join(dir, "clients.json")
|
|
|
|
//nolint:gosec // a file in the test's directory
|
|
clients, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("read clients.json: %v", err)
|
|
}
|
|
|
|
stamp := regexp.MustCompile(`"\d{4}-\d\d-\d\dT[^"]*"`)
|
|
|
|
times := stamp.FindAllString(string(clients), -1)
|
|
if len(times) == 0 {
|
|
t.Errorf("clients.json holds no time:\n%s", clients)
|
|
}
|
|
|
|
for _, stored := range times {
|
|
wantUTC(t, "clients.json", strings.Trim(stored, `"`))
|
|
}
|
|
}
|
|
|
|
// wantUTC checks that value, a time read from the log line or file that
|
|
// where names, is in UTC.
|
|
func wantUTC(t *testing.T, where string, value any) {
|
|
t.Helper()
|
|
|
|
text, _ := value.(string)
|
|
if !strings.HasSuffix(text, "Z") {
|
|
t.Errorf("%s gives the time %v, want one in UTC", where, value)
|
|
}
|
|
}
|
|
|
|
func TestMainWithoutACommandItKnowsPrintsTheCommands(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
binary, err := os.Executable()
|
|
if err != nil {
|
|
t.Fatalf("find the test binary: %v", err)
|
|
}
|
|
|
|
for _, command := range []string{"", "serve"} {
|
|
t.Run("command "+command, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx, cancel := context.WithTimeout(t.Context(), waitLimit)
|
|
defer cancel()
|
|
|
|
var stdout, stderr bytes.Buffer
|
|
|
|
cmd := exec.CommandContext(ctx, binary)
|
|
cmd.Stdout, cmd.Stderr = &stdout, &stderr
|
|
|
|
cmd.Env = append(os.Environ(), commandForMain+"="+command)
|
|
|
|
err := cmd.Run()
|
|
|
|
if code := cmd.ProcessState.ExitCode(); code != 2 {
|
|
t.Errorf("exit status %d (%v), want 2", code, err)
|
|
}
|
|
|
|
for _, name := range []string{"rproxy", wafCommand, "healthcheck"} {
|
|
if !strings.Contains(stderr.String(), name) {
|
|
t.Errorf(
|
|
"stderr %q does not name %s",
|
|
stderr.String(),
|
|
name,
|
|
)
|
|
}
|
|
}
|
|
|
|
if stdout.Len() != 0 {
|
|
t.Errorf("stdout %q, want nothing", stdout.String())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// ask sends waf at addr rproxy's question about a request for path from
|
|
// placed, checks the answer's status and disposition, and closes it.
|
|
func ask(t *testing.T, addr, path string, status int, disposition string) {
|
|
t.Helper()
|
|
|
|
req, err := http.NewRequestWithContext(t.Context(), http.MethodGet,
|
|
"http://"+addr+path, http.NoBody)
|
|
if err != nil {
|
|
t.Fatalf("new request: %v", err)
|
|
}
|
|
|
|
req.Header.Set(waf.ClientHeader, placed)
|
|
req.Header.Set("X-Request-ID", rand.Text())
|
|
|
|
transport := &http.Transport{}
|
|
defer transport.CloseIdleConnections()
|
|
|
|
res, err := (&http.Client{Transport: transport}).Do(req)
|
|
if err != nil {
|
|
t.Fatalf("question: %v", err)
|
|
}
|
|
|
|
_, _ = io.Copy(io.Discard, res.Body)
|
|
_ = res.Body.Close()
|
|
|
|
if res.StatusCode != status ||
|
|
res.Header.Get(waf.DispositionHeader) != disposition {
|
|
t.Errorf(
|
|
"answered %d with disposition %q, want %d with %q",
|
|
res.StatusCode,
|
|
res.Header.Get(waf.DispositionHeader),
|
|
status,
|
|
disposition,
|
|
)
|
|
}
|
|
}
|
|
|
|
// runWAF runs `sww waf` with the settings in env, has use
|
|
// send it requests at the address it listens on, stops it as SIGTERM does, and
|
|
// checks that it stopped in order.
|
|
func runWAF(t *testing.T, env map[string]string, use func(addr string)) {
|
|
t.Helper()
|
|
|
|
ctx, stop := context.WithCancel(t.Context())
|
|
out := &output{}
|
|
exited := make(chan int, 1)
|
|
|
|
go func() {
|
|
exited <- run(ctx, env, out)
|
|
}()
|
|
|
|
addr, _ := out.lineBeforeExit(t, "starting", exited)["address"].(string)
|
|
use(addr)
|
|
stop()
|
|
|
|
select {
|
|
case status := <-exited:
|
|
if status != 0 {
|
|
t.Fatalf(
|
|
"exit status %d, want 0; output:\n%s",
|
|
status,
|
|
out.text(),
|
|
)
|
|
}
|
|
case <-time.After(waitLimit):
|
|
t.Fatal("still running after being told to stop")
|
|
}
|
|
|
|
out.line(t, "msg", "stopped")
|
|
}
|
|
|
|
func TestWAFKeepsItsBansAcrossARestartAndNeedsNoApp(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
env := map[string]string{
|
|
listenAddr: localhost + ":0",
|
|
stateDir: t.TempDir(),
|
|
ruleFilesDir: filepath.Join("..", "..", "share", "rules.d"),
|
|
}
|
|
|
|
runWAF(t, env, func(addr string) {
|
|
ask(t, addr, "/", http.StatusOK, waf.DispositionAllow)
|
|
// The default rule file bans a probe for this.
|
|
ask(t, addr, "/.env", http.StatusForbidden, waf.DispositionDeny)
|
|
})
|
|
|
|
runWAF(t, env, func(addr string) {
|
|
ask(t, addr, "/", http.StatusForbidden, waf.DispositionDeny)
|
|
})
|
|
}
|