fix(notify): break every backtick so long runs cannot reform a fence

replacing exact triples left a trailing bare backtick, so a run whose
length is 2 mod 3 (5, 8, 11...) came back out with three adjacent
backticks and reopened the block. discord takes the sanitized body with
no entity escaping, so that was a live breakout for mentions and masked
links.

the breakout test only covered n=3; it now walks 3,4,5,6,8,11 and fails
on the old behaviour at n=5.

Author: TBX3D

internal/notify/notify_test.go

@@ -278,25 +278,30 @@ func TestNotifyCodeBlockBreakoutNeutralized(t *testing.T) {
 	var c capture
 	srv := captureServer(t, &c)
 
-	evil := []finding.Finding{{
-		Target:   "https://evil.test",
-		Module:   "probe",
-		Severity: finding.SeverityHigh,
-		Key:      "probe:x",
-		Title:    "```\n@everyone pwned <https://evil.test|click>\n```",
-	}}
-	p := &discordProvider{webhook: srv.URL}
-	if err := p.send(context.Background(), srv.Client(), evil); err != nil {
-		t.Fatalf("send: %v", err)
-	}
-	var payload discordPayload
-	if err := json.Unmarshal(c.body, &payload); err != nil {
-		t.Fatalf("unmarshal: %v", err)
-	}
-	// a clean payload has exactly the 2 fences we added (open+close); any more
-	// means attacker content broke out.
-	if fences := strings.Count(payload.Content, "```"); fences > 2 {
-		t.Fatalf("INJECTION: attacker content added %d extra code fences, breaking out: %q", fences-2, payload.Content)
+	// a backtick run of any length has to come out broken; 5, 8 and 11 are the
+	// lengths that reformed a fence when only exact triples were replaced.
+	for _, n := range []int{3, 4, 5, 6, 8, 11} {
+		run := strings.Repeat("`", n)
+		evil := []finding.Finding{{
+			Target:   "https://evil.test",
+			Module:   "probe",
+			Severity: finding.SeverityHigh,
+			Key:      "probe:x",
+			Title:    run + "\n@everyone pwned <https://evil.test|click>\n" + run,
+		}}
+		p := &discordProvider{webhook: srv.URL}
+		if err := p.send(context.Background(), srv.Client(), evil); err != nil {
+			t.Fatalf("run of %d: send: %v", n, err)
+		}
+		var payload discordPayload
+		if err := json.Unmarshal(c.body, &payload); err != nil {
+			t.Fatalf("run of %d: unmarshal: %v", n, err)
+		}
+		// a clean payload has exactly the 2 fences we added (open+close); any more
+		// means attacker content broke out.
+		if fences := strings.Count(payload.Content, "```"); fences > 2 {
+			t.Fatalf("INJECTION: run of %d backticks added %d extra code fences, breaking out: %q", n, fences-2, payload.Content)
+		}
 	}
 }
 

internal/notify/slack.go

@@ -57,11 +57,14 @@ func codeBlock(body string) string {
 	return "```\n" + sanitizeFence(body) + "```"
 }
 
-// sanitizeFence breaks up any triple-backtick run inside body by interleaving
-// zero-width spaces between the backticks. the text still reads as backticks
-// to a human but neither slack nor discord treats it as a fence boundary, so
-// it can't prematurely close the code block we wrap it in.
+// sanitizeFence separates every backtick in body from the next with a
+// zero-width space. the text still reads as backticks to a human but no two
+// are ever adjacent, so neither slack nor discord sees a fence boundary and
+// attacker content can't close the code block we wrap it in.
+//
+// breaking exact triples instead would leave a trailing bare backtick, and any
+// run of length \u2261 2 mod 3 (5, 8, 11...) would reform a contiguous triple.
 func sanitizeFence(body string) string {
 	const zwsp = "\u200b" // zero-width space
-	return strings.ReplaceAll(body, "```", "`"+zwsp+"`"+zwsp+"`")
+	return strings.ReplaceAll(body, "`", "`"+zwsp)
 }