From 8d22bceac9933c252db8461c571f17f097dcfc86 Mon Sep 17 00:00:00 2001
From: nichtLehdev <lars@lehdev.de>
Date: Fri, 18 Sep 2026 10:32:07 +0200
Subject: [PATCH] fix(sicherheit): Klartext-Helfer laesst garantiert keine Tags
 stehen

CodeQL meldete am Release-PR vier Warnungen hoher Stufe im Klartext-
Helfer aus #311:

- Tags wurden in einem Durchgang entfernt. Aus <<b>script> macht das
  <script> -- das Entfernen selbst setzt ein neues Tag zusammen. Jetzt
  wird wiederholt, bis sich nichts mehr aendert.
- Entitaeten wurden nach dem Abraeumen und nacheinander aufgeloest: Aus
  &lt;script&gt; wurde hinterher wieder <script>, und &amp;lt; wurde
  doppelt entschluesselt. Jetzt in einem Durchgang und danach noch einmal
  abgeraeumt.

Der Klartext wird heute nirgends als HTML ausgefuehrt (iCal, Metadaten,
Suche), soll aber von sich aus frei von Tags sein. Spitze Klammern im
Text ("Kinder <10 Jahre", "a < b") bleiben stehen. Die Test-Hilfsfunktion
folgt denselben Regeln; neue Tests fuer die Angriffsmuster.
---
 src/lib/__tests__/beschreibung.test.ts | 62 ++++++++++++++++++++++----
 src/lib/markdown-to-plain-text.ts      | 48 ++++++++++++++++----
 2 files changed, 92 insertions(+), 18 deletions(-)

diff --git a/src/lib/__tests__/beschreibung.test.ts b/src/lib/__tests__/beschreibung.test.ts
index 0c4af3aa..5679286b 100644
--- a/src/lib/__tests__/beschreibung.test.ts
+++ b/src/lib/__tests__/beschreibung.test.ts
@@ -12,19 +12,32 @@ import {
  * Text meinen — deshalb prüft der letzte Block sie gegeneinander.
  */
 
-/** Grobes Abräumen der Tags, nur für den Vergleich der beiden Enden. */
+const TEST_ENTITIES: Record<string, string> = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+};
+
+/**
+ * Grobes Abräumen der Tags, nur für den Vergleich der beiden Enden. Tags bis
+ * zur Ruhe, Entitäten in einem Durchgang — dieselben Regeln wie im Helfer,
+ * sonst meldet CodeQL auch hier unvollständiges Abräumen.
+ */
 function htmlZuText(html: string): string {
-  return html
+  let text = html
     .replace(/>\n+</g, "><")
     .replace(/<br\s*\/?>/g, "\n")
     .replace(/<\/li>/g, "\n")
-    .replace(/<\/(p|h[1-6]|ul|ol|blockquote)>/g, "\n\n")
-    .replace(/<[^>]+>/g, "")
-    .replace(/&amp;/g, "&")
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
+    .replace(/<\/(p|h[1-6]|ul|ol|blockquote)>/g, "\n\n");
+  let vorher: string;
+  do {
+    vorher = text;
+    text = text.replace(/<[^<>]+>/g, "");
+  } while (text !== vorher);
+  return text
+    .replace(/&(?:amp|lt|gt|quot|#39);/g, (e) => TEST_ENTITIES[e] ?? e)
     .replace(/\n{3,}/g, "\n\n")
     .trim();
 }
@@ -173,3 +186,34 @@ describe("Klartext und Darstellung sagen dasselbe", () => {
     );
   });
 });
+
+/**
+ * CodeQL meldete, dass ein einzelner Durchgang Tags neu zusammensetzen kann
+ * und Entitäten nach dem Abräumen wieder Tags ergeben. Klartext wird nirgends
+ * ausgeführt, soll aber von sich aus frei von Tags sein.
+ */
+describe("markdownToPlainText — keine Tags im Ergebnis", () => {
+  const ohneSkript = (eingabe: string) =>
+    expect(markdownToPlainText(eingabe).toLowerCase()).not.toContain("<script");
+
+  it("setzt beim Abräumen kein neues Tag zusammen", () => {
+    ohneSkript("<<b>script>alert(1)<</b>/script>");
+    ohneSkript("<scr<script>x</script>ipt>alert(1)</script>");
+    ohneSkript("<<script>script>alert(1)<</script>/script>");
+  });
+
+  it("lässt aus Entitäten keine Tags entstehen", () => {
+    ohneSkript("&lt;script&gt;alert(1)&lt;/script&gt;");
+    expect(markdownToPlainText("&lt;b&gt;fett&lt;/b&gt;")).toBe("fett");
+  });
+
+  it("entschlüsselt Entitäten nur einmal", () => {
+    expect(markdownToPlainText("&amp;lt;")).toBe("&lt;");
+    expect(markdownToPlainText("Bläser &amp; Chor")).toBe("Bläser & Chor");
+  });
+
+  it("lässt spitze Klammern im Text stehen", () => {
+    expect(markdownToPlainText("Kinder <10 Jahre")).toBe("Kinder <10 Jahre");
+    expect(markdownToPlainText("a < b und c > d")).toBe("a < b und c > d");
+  });
+});
diff --git a/src/lib/markdown-to-plain-text.ts b/src/lib/markdown-to-plain-text.ts
index a34b69a0..1ffe20a3 100644
--- a/src/lib/markdown-to-plain-text.ts
+++ b/src/lib/markdown-to-plain-text.ts
@@ -22,6 +22,33 @@ const ENTITIES: Record<string, string> = {
  */
 const MASKIERT_AB = 0xe000;
 
+/**
+ * Wendet eine Ersetzung an, bis sich nichts mehr ändert. Ein einzelner
+ * Durchgang reicht beim Entfernen von Tags nicht: Aus `<<b>script>` macht er
+ * `<script>` — das Entfernen selbst setzt ein neues Tag zusammen (CodeQL:
+ * „Incomplete multi-character sanitization").
+ */
+function bisStabil(text: string, muster: RegExp, ersatz = ""): string {
+  let vorher: string;
+  do {
+    vorher = text;
+    text = text.replace(muster, ersatz);
+  } while (text !== vorher);
+  return text;
+}
+
+/** Skript- und Stilblöcke samt Inhalt. */
+const SKRIPT_ODER_STIL = /<(script|style)\b[\s\S]*?<\/\1\s*>/gi;
+
+/**
+ * Nur echte Tags, nicht jedes spitze Klammerpaar: „Kinder <10 Jahre" und
+ * „a < b" sind Text und werden in der Anzeige auch als Text dargestellt.
+ */
+const TAG = /<\/?[a-zA-Z][^<>]*>/g;
+
+/** Alle bekannten Entitäten in einem Muster — für eine einzige Auflösung. */
+const ENTITY = /&(?:amp|lt|gt|quot|#39|apos|nbsp);/g;
+
 /**
  * Wandelt Markdown in Klartext um.
  *
@@ -63,13 +90,11 @@ export function markdownToPlainText(markdown: string): string {
   // diese Zeile bliebe von `<script>alert(1)</script>` das „alert(1)" im
   // Kalendereintrag stehen — gemessen. Gefährlich ist das nicht (Klartext
   // wird nirgends ausgeführt), nur falsch.
-  text = text.replace(/<(script|style)\b[\s\S]*?<\/\1\s*>/gi, "");
+  text = bisStabil(text, SKRIPT_ODER_STIL);
 
-  // Sonst nur echte Tags entfernen, nicht jedes spitze Klammerpaar: „Kinder
-  // <10 Jahre" ist Text und wird in der Anzeige auch als Text dargestellt.
-  // Die frühere Fassung löschte pauschal `<` und `>` und machte aus
-  // `<u>Wort</u>` das Wort „uWort/u".
-  text = text.replace(/<\/?[a-zA-Z][^<>]*>/g, "");
+  // Sonst nur echte Tags entfernen (siehe `TAG`). Die frühere Fassung
+  // löschte pauschal `<` und `>` und machte aus `<u>Wort</u>` „uWort/u".
+  text = bisStabil(text, TAG);
 
   // Das Ziel darf ein Klammerpaar enthalten (`javascript:alert(1)`, aber auch
   // Wikipedia-Adressen mit Klammern) — eine Ebene reicht dafür. Vorher blieb
@@ -103,9 +128,14 @@ export function markdownToPlainText(markdown: string): string {
     String.fromCharCode(zeichen.charCodeAt(0) - MASKIERT_AB),
   );
 
-  for (const [entity, char] of Object.entries(ENTITIES)) {
-    text = text.split(entity).join(char);
-  }
+  // In einem einzigen Durchgang: Nacheinander aufgelöst würde aus „&amp;lt;"
+  // erst „&lt;" und dann „<" — doppelt entschlüsselt.
+  text = text.replace(ENTITY, (entity) => ENTITIES[entity] ?? entity);
+
+  // Aufgelöste Entitäten können Tags ergeben („&lt;script&gt;" → „<script>").
+  // Klartext wird zwar nirgends ausgeführt, aber er soll von sich aus sicher
+  // sein, egal wo ihn jemand später einsetzt — also noch einmal abräumen.
+  text = bisStabil(bisStabil(text, SKRIPT_ODER_STIL), TAG);
 
   text = text.replace(/[ \t]+$/gm, "");
   text = text.replace(/[ \t]{2,}/g, " ");