Texterkennung in Grenzen zwingen, die das Dokument nicht selbst setzt

Zwei Wege, auf denen ein hochgeladenes Dokument den Server umbringen
konnte. Beide haben gemeinsam, dass die Groesse aus der Datei kam.

1. Dekompressionsbombe. Die PDF-Stroeme wurden mit inflateSync ohne
   maxOutputLength ausgepackt. Ein Flate-Strom sagt nicht, wie gross er
   ausgepackt wird - ein paar Kilobyte Fuellung blaehen sich auf Gigabyte
   auf. Jetzt ein Deckel je Strom (8 MB) und einer ueber die Summe
   (64 MB); zlib bricht selbst ab, der Strom wird verworfen, der Text ist
   eben unvollstaendig.

2. Riesenseiten. "pdftoppm -r 300" rendert mit fester Aufloesung, aber
   die Seitengroesse steht im PDF. Bei 200 x 200 Zoll ergeben 300 dpi ein
   Bild von 60000 x 60000 Pixeln, und zwar je Seite. Jetzt "-scale-to"
   statt fester dpi: Die laengste Kante bekommt eine feste Pixelzahl,
   unabhaengig davon, was im Dokument als Papierformat steht. Fuer A4
   entspricht das etwa den bisherigen 300 dpi. Dazu ein Deckel auf die
   Gesamtgroesse der gerenderten Dateien.

Der erste Bombentest war wertlos: Die Nutzlast enthielt keine
PDF-Textoperatoren, also war das Ergebnis mit und ohne Grenze leer. Mit
einer Marke in der Nutzlast und einer Gegenprobe knapp unter der Grenze
schlagen beide Mutationen an.

Refs #38

src/lib/ocr/pdf-text.ts

@@ -15,8 +15,33 @@ import { inflateSync, inflateRawSync, unzipSync } from 'node:zlib'
  * "nicht_verfuegbar", und der Nutzer traegt die Metadaten von Hand ein.
  *
  * Rein, ohne Seiteneffekte, ohne Netz.
+ *
+ * ## Grenzen, und warum es sie braucht
+ *
+ * Ein Flate-Strom sagt nicht, wie gross er ausgepackt wird. Ein paar
+ * Kilobyte Nullen komprimieren auf fast nichts und blaehen sich beim
+ * Auspacken auf Gigabyte auf - die klassische Dekompressionsbombe. Vorher
+ * lief das Auspacken ohne Obergrenze, und ein Dokument, das jemand in die
+ * Akte legt, haette den Server damit aus dem Speicher werfen koennen.
+ *
+ * Deshalb drei Deckel: einer je Strom, einer fuer die Summe, und die
+ * bestehende Obergrenze von 2000 Stroemen. Wird einer erreicht, bricht das
+ * Auspacken ab und der Text ist eben unvollstaendig - besser ein
+ * "nicht_verfuegbar" als ein Serverneustart.
  */
 
+/**
+ * Wie gross ein einzelner ausgepackter Strom werden darf.
+ *
+ * Acht Megabyte sind fuer eine Seite Text absurd viel - ein
+ * Behoerdenbescheid liegt bei einigen Kilobyte. Die Grenze ist bewusst
+ * grosszuegig: Sie soll Bomben abfangen, nicht ungewoehnliche PDFs.
+ */
+const MAX_STROM_BYTES = 8 * 1024 * 1024
+
+/** Und wie viel es ueber alle Stroeme zusammen sein darf. */
+const MAX_GESAMT_BYTES = 64 * 1024 * 1024
+
 /** Oktal-Escapes und Standard-Escapes in PDF-Literalstrings. */
 function literalEntpacken(roh: string): string {
   let ergebnis = ''
@@ -108,8 +133,9 @@ function stroemeAuspacken(pdf: Buffer): string[] {
   const roh = pdf.toString('latin1')
   const stroeme: string[] = []
   let suchAb = 0
+  let gesamt = 0
 
-  while (stroeme.length < 2000) {
+  while (stroeme.length < 2000 && gesamt < MAX_GESAMT_BYTES) {
     const beginn = roh.indexOf('stream', suchAb)
     if (beginn < 0) break
 
@@ -131,28 +157,50 @@ function stroemeAuspacken(pdf: Buffer): string[] {
     }
 
     if (/\/Filter\s*(\/FlateDecode|\[\s*\/FlateDecode)/.test(kopf)) {
-      const entpackt = flateVersuchen(daten)
-      if (entpackt) stroeme.push(entpackt.toString('latin1'))
+      const entpackt = flateVersuchen(daten, MAX_GESAMT_BYTES - gesamt)
+      if (entpackt) {
+        gesamt += entpackt.length
+        stroeme.push(entpackt.toString('latin1'))
+      }
       continue
     }
 
     if (!/\/Filter/.test(kopf)) {
+      // Unkomprimiert: Hier gibt es nichts, was sich aufblaehen koennte -
+      // die Bytes stehen so in der Datei. Sie zaehlen trotzdem mit, damit
+      // die Summe stimmt.
+      gesamt += daten.length
       stroeme.push(daten.toString('latin1'))
       continue
     }
 
     // Unbekannter Filter: trotzdem einen Flate-Versuch wagen.
-    const entpackt = flateVersuchen(daten)
-    if (entpackt) stroeme.push(entpackt.toString('latin1'))
+    const entpackt = flateVersuchen(daten, MAX_GESAMT_BYTES - gesamt)
+    if (entpackt) {
+      gesamt += entpackt.length
+      stroeme.push(entpackt.toString('latin1'))
+    }
   }
 
   return stroeme
 }
 
-function flateVersuchen(daten: Buffer): Buffer | null {
+/**
+ * Packt einen Strom aus - mit Deckel.
+ *
+ * maxOutputLength laesst zlib abbrechen, sobald die Ausgabe die Grenze
+ * ueberschreitet; der Fehler landet im catch wie jeder andere. Ohne diese
+ * Angabe entpackt Node so lange, wie Speicher da ist.
+ *
+ * @param rest Wie viele Bytes ueber alle Stroeme noch uebrig sind.
+ */
+function flateVersuchen(daten: Buffer, rest: number): Buffer | null {
+  const grenze = Math.min(MAX_STROM_BYTES, rest)
+  if (grenze <= 0) return null
+
   for (const fn of [inflateSync, unzipSync, inflateRawSync]) {
     try {
-      return fn(daten)
+      return fn(daten, { maxOutputLength: grenze })
     } catch {
       // naechster Versuch
     }