From de153dc13a72efdbed81ba4ba2c458ab29309503 Mon Sep 17 00:00:00 2001
From: Debian <linux@myhorse.netcell-it.de>
Date: Tue, 4 Aug 2026 10:00:17 +0200
Subject: [PATCH] =?UTF-8?q?fix(waf):=20GET-Requests=20ohne=20Body=20wurden?=
 =?UTF-8?q?=20von=20allen=20Phase-2-Regeln=20nie=20gepr=C3=BCft=20?=
 =?UTF-8?q?=E2=80=94=20v1.3.18?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Schwerwiegende WAF-Lücke: der SPOE-Agent rief tx.ProcessRequestBody() nur bei
len(body)>0 auf. In Coraza wird die GESAMTE Phase 2 (SQLi 942xxx, XSS 941xxx,
LFI/RCE — alle prüfen ARGS aus dem Query-String) aber erst von
ProcessRequestBody() ausgewertet. Damit lief jeder GET-Request ohne Body
komplett ungeprüft an den Injection-Regeln vorbei — der häufigste
Web-Angriffsvektor (?id=1' OR 1=1, ?x=<script>) war blind. Nur Requests MIT
Body (POST/PUT/PROPFIND-XML) wurden inspiziert.

Fix: ProcessRequestBody() läuft jetzt IMMER (mit/ohne Body). Regressionstest
TestPhase2RequiresProcessRequestBody nagelt die Semantik fest.

Alle 9 aktiven WAF-Domains sind in Detection-Modus → der Fix erzeugt nur mehr
(echte) Alerts, blockt nichts.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 VERSION                          |  2 +-
 internal/waf/spoe.go             | 24 ++++++++++-----
 internal/waf/spoe_phase2_test.go | 50 ++++++++++++++++++++++++++++++++
 3 files changed, 67 insertions(+), 9 deletions(-)
 create mode 100644 internal/waf/spoe_phase2_test.go

diff --git a/VERSION b/VERSION
index a930824..672b322 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.3.17
\ No newline at end of file
+1.3.18
\ No newline at end of file
diff --git a/internal/waf/spoe.go b/internal/waf/spoe.go
index 2f9ffc0..785516b 100644
--- a/internal/waf/spoe.go
+++ b/internal/waf/spoe.go
@@ -131,14 +131,22 @@ func (a *SPOEAgent) handle(ctx context.Context, w *encoding.ActionWriter, m *enc
 	// liefert den Body via `option http-buffer-request` (bis tune.bufsize) —
 	// größere Bodies werden zur Prüfung gekappt. Content-Type kam bereits
 	// über die Header, sodass Coraza urlencoded/multipart/json korrekt parst.
-	if interruption == nil && len(body) > 0 {
-		if it, _, err := tx.WriteRequestBody(body); err != nil {
-			slog.Warn("waf: WriteRequestBody", "error", err)
-		} else if it != nil {
-			interruption = it
-		} else {
-			it, err := tx.ProcessRequestBody()
-			if err != nil {
+	if interruption == nil {
+		if len(body) > 0 {
+			if it, _, err := tx.WriteRequestBody(body); err != nil {
+				slog.Warn("waf: WriteRequestBody", "error", err)
+			} else if it != nil {
+				interruption = it
+			}
+		}
+		// ProcessRequestBody MUSS immer laufen — auch ohne Body. In Coraza wird
+		// die GESAMTE Phase 2 (SQLi 942xxx, XSS 941xxx, die den Query-String/ARGS
+		// prüfen) erst hier ausgewertet. Wurde das an len(body)>0 gekoppelt,
+		// blieben GET-Requests ohne Body von allen Phase-2-Regeln ungeprüft →
+		// Query-String-Angriffe (?id=1' OR 1=1, ?x=<script>) liefen komplett
+		// durch. Der häufigste Web-Angriffsvektor war damit blind.
+		if interruption == nil {
+			if it, err := tx.ProcessRequestBody(); err != nil {
 				slog.Warn("waf: ProcessRequestBody", "error", err)
 			} else if it != nil {
 				interruption = it
diff --git a/internal/waf/spoe_phase2_test.go b/internal/waf/spoe_phase2_test.go
new file mode 100644
index 0000000..11c699b
--- /dev/null
+++ b/internal/waf/spoe_phase2_test.go
@@ -0,0 +1,50 @@
+package waf
+
+import (
+	"testing"
+
+	"github.com/corazawaf/coraza/v3"
+)
+
+// TestPhase2RequiresProcessRequestBody nagelt die Coraza-Semantik fest, die der
+// SPOE-Bug verletzt hatte: Phase-2-Regeln (SQLi 942xxx, XSS 941xxx — sie prüfen
+// ARGS aus dem Query-String) werden ERST von ProcessRequestBody() ausgewertet.
+// Koppelt man ProcessRequestBody an len(body)>0, bleiben GET-Requests ohne Body
+// von der gesamten Phase 2 ungeprüft. Dieser Test schlägt fehl, sollte jemand
+// den Aufruf je wieder body-abhängig machen.
+func TestPhase2RequiresProcessRequestBody(t *testing.T) {
+	waf, err := coraza.NewWAF(coraza.NewWAFConfig().WithDirectives(
+		"SecRuleEngine DetectionOnly\n" +
+			"SecRule ARGS \"@rx attackpattern\" \"id:1234,phase:2,log,msg:'phase2-arg'\"\n"))
+	if err != nil {
+		t.Fatalf("NewWAF: %v", err)
+	}
+	tx := waf.NewTransaction()
+	defer func() { tx.ProcessLogging(); _ = tx.Close() }()
+
+	tx.ProcessConnection("1.2.3.4", 0, "", 0)
+	tx.ProcessURI("/?x=attackpattern", "GET", "HTTP/1.1") // GET, kein Body
+	tx.AddRequestHeader("Host", "test")
+	tx.ProcessRequestHeaders()
+
+	// Vor ProcessRequestBody darf die Phase-2-Regel noch NICHT gefeuert haben.
+	if n := len(tx.MatchedRules()); n != 0 {
+		t.Fatalf("vor ProcessRequestBody: %d Matches, erwarte 0", n)
+	}
+
+	if _, err := tx.ProcessRequestBody(); err != nil {
+		t.Fatalf("ProcessRequestBody: %v", err)
+	}
+
+	// Jetzt MUSS die Phase-2-Regel gegen den Query-Arg gefeuert haben.
+	found := false
+	for _, mr := range tx.MatchedRules() {
+		if mr.Rule().ID() == 1234 {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("Phase-2-Regel feuerte auch nach ProcessRequestBody nicht — " +
+			"GET-Query-Args würden ungeprüft bleiben (SPOE-Bug)")
+	}
+}