Fundierte Artikel über Technologien, die das Kommende formen.

Ruby-Regex-Lücken: Unicode-Case-Folding wird gefährlich

Sieben Ruby-Regex- und String-Schwachstellen zeigen, warum Unicode-Case-Folding ein Speicherproblem ist. So prüfst du deinen Code.

Ein Bleisatz-Block, der über einem Druckerkasten in zwei kleinere Blöcke zerfällt
Dass aus einem Zeichen zwei werden, ist der ganze Bug: Aus dem großen ß wird SS, und die Puffer-Berechnung gerät aus den Fugen.

Eine Rails-App normalisiert E-Mail-Adressen, indem sie sie vor dem Speichern mit upcase umwandelt, so wie es tausend Tutorials empfehlen. Ein Nutzer meldet sich mit mueller@straße.example an, und irgendwo in der Pipeline hat jemand Windows-1252 für eine gute Idee gehalten. Der Aufruf upcase macht aus dem finalen ß ein SS – zwei Bytes, wo vorher eins stand – und schreibt eines davon hinter das Ende eines Heap-Puffers. Das ist nicht hypothetisch. Es ist eine plausible Rekonstruktion einer der sieben Schwachstellen bei Regex- und String-Case-Konvertierung in Ruby, die das Core-Team gerade geschlossen hat, und mehrere davon haben funktionierende Proof-of-Concepts für Remote Code Execution.

Die Advisory erschien zusammen mit drei Notfall-Releases – Ruby 4.0.10, 3.4.13 und 3.3.14 – und sie ist ein lehrreiches Beispiel für eine tiefere Wahrheit: Case-Konvertierung wirkt wie die simpelste Operation einer String-Bibliothek und ist in Wirklichkeit eine der gefährlichsten. Hier trifft die weitläufige Unicode-Spezifikation auf jahrzehntealten C-Code, und genau an dieser Naht wachsen Heap-Overflows.

Sieben Bugs, zwei Subsysteme, eine Grundursache

Die sieben Advisories (verfolgt über GHSA-Kennungen, während die CVE-Nummern einen Rückstau bei der Vergabe abarbeiten) gruppieren sich in zwei Familien. Zwei betreffen die Case-Konvertierung in String: ein Ein-Byte-Heap-Buffer-Overflow und ein Integer-Overflow, der in einen Heap-Overflow kaskadiert. Fünf betreffen Rubys Regex-Engine – ein Double Free bei der Muster-Kompilierung, ein Integer-Overflow während der Kompilierung, ein Out-of-Bounds-Read beim Case-insensitive-Matching, ein Out-of-Bounds-Read beim Matching von Backreferences ohne Berücksichtigung der Groß-/Kleinschreibung und ein Heap-Buffer-Overflow in Regexp#to_s.

Achte darauf, was sie verbindet. Es ist nicht schlampiges Programmieren im üblichen Sinne – Rubys C-Kern ist alt, bewährt und ausgiebig gefuzzt. Es ist vielmehr, dass beide Subsysteme Unicode-Case-Semantik implementieren, und Unicode-Case-Semantik ist eine Falle. Case-insensitives Regex-Matching verlangt, sowohl Muster als auch Eingabe zu falten, was bedeutet, dass die Engine dieselben heiklen Mapping-Tabellen nutzt wie String#upcase, nur auf einem heißeren Pfad und mit mehr Einfluss von Angreifern auf die Eingaben. Backreferences im case-insensitiven Modus müssen gefaltete Teilstrings vergleichen. Regexp#to_s muss den Quelltext eines Musters samt Optionen wieder ausgeben und dafür einen Puffer dimensionieren, dessen Rekonstruktion selbst case-abhängige Logik enthält. Jeder dieser Codepfade muss dieselbe trügerisch schwierige Frage beantworten: Wie groß ist dieser String, nachdem ich seine Groß-/Kleinschreibung geändert habe?

Ruby 3.3 bekommt den Fix, weil die Version noch in der Security-Wartung ist. Ruby 3.2 und älter sind End of Life und gehen leer aus. Wenn du eine dieser Versionen nutzt, ist diese Advisory deine Migrationsfrist, nicht bloß eine Warnung.

Eine kurze Geschichte der Case-Konvertierung, die schiefging

In ASCII ist ein Case-Wechsel ein Bit-Flip. Sechsundzwanzig Buchstabenpaare, eins zu eins, längenerhaltend, unabhängig von der Locale. toupper() aus der C-Welt der K&R-Ära verkörpert die ganze Idee in einer einzigen Lookup-Tabelle. Dieses mentale Modell tragen die meisten von uns ins Erwachsenenleben mit, und es steckt in der Puffer-Dimensionierung im C-Code der halben Welt. Für praktisch jedes Schriftsystem jenseits des Basis-Lateinischen ist es aber falsch.

Unicode definiert Tausende Case-Mappings, und ein erheblicher Teil davon ist nicht eins zu eins. Das deutsche Eszett (ß) wird zu SS. Die Ligatur ff wird zu FF. Armenische Ligaturen expandieren. Griechisch kennt das kontextabhängige Sigma – σ versus finales ς –, sodass korrektes Falten von den umgebenden Zeichen abhängt. Türkisch und Aserbaidschanisch haben das Problem mit dem punktierten und punktlosen I: i wird zu İ, ı zu I. Das brachte berüchtigterweise alles Mögliche zum Absturz, von Java-Apps bis zu PHPs strtoupper in türkischen Locales. Und Cherokee bekam 2015 mit Unicode 8.0 nachträglich Kleinbuchstaben hinzugefügt. Aus einer Schrift ohne Groß-/Kleinschreibung wurde eine mit, und Annahmen in Software überall wurden ungültig.

Die Legacy-Encodings machen es schlimmer. Windows-1252 hat ein Byte für das kleine ß (0xDF), aber kein Byte für eine hypothetische Großversion, weil Deutsch im Fließtext historisch schlicht keine verwendet hat; man schrieb SS. Wenn eine Case-Konvertierung auf einem Windows-1252-String auf ein ß trifft und es korrekt durch SS ersetzt, wächst der String um ein Byte. Die scharfsinnigen Analysen nach der Advisory legen nahe, dass genau dies der Ein-Byte-Overflow ist: Die Konvertierungsschleife prüft den Pufferplatz offenbar Zeichen für Zeichen, sodass ein ß als letztes Zeichen eines knapp dimensionierten Strings ein verirrtes S hinter die Allokation schreibt. Ein Ein-Byte-Heap-Overflow mit einem vom Angreifer kontrollierten S ist ein mühsamer, fummeliger Exploit-Baustein. Aber die Advisory bestätigt, dass PoCs mit RCE existieren, also hat jemand das Heap-Grooming gemacht.

Case-Konvertierung ist keine Bijektion, nicht längenerhaltend, nicht unabhängig von der Locale und nicht in jedem Encoding darstellbar. Code, der etwas anderes annimmt, ist eine Schwachstelle, die nur auf einen Fuzzer wartet.

Warum die Regex-Engine das größere Problem ist

Rubys Regex-Engine ist Onigmo, ein Fork von Oniguruma, und ein wirklich beeindruckendes Stück Software. Sie unterstützt Dutzende Encodings, vollständiges Unicode-Case-Folding, Lookbehinds, benannte Gruppen und Backreferences, alles in C, mit einer Schichtung, die bis in die späten 1990er zurückreicht. Genau diese Schichtung ist das Problem. Case-insensitives Matching bedeutet in Onigmo, dass jeder Vergleichspunkt potenziell Falt-Logik ausführt, und Falten verändert Längen. Die Buchführung zwischen Muster-Offsets, String-Offsets und Match-Grenzen ist daher außerordentlich verzwickt. Zwei der gepatchten Bugs sind Out-of-Bounds-Reads genau in dieser Maschinerie: einer beim case-insensitiven Matching allgemein, einer speziell beim case-insensitiven Backreference-Matching, wo die Engine einen zuvor erfassten (gefalteten) Teilstring mit der aktuellen Position vergleicht.

Das Ausnutzungsmodell wiegt aber mehr als die Interna. Drei der fünf Regex-Bugs werden während der Muster-Kompilierung ausgelöst, und die Advisory ist eindeutig, wer betroffen ist: Anwendungen, die vom Angreifer kontrollierte Muster kompilieren. Man könnte meinen, das sei selten. Ist es nicht. Jedes Suchfeld, das in Regexp.new(query) verpackt wird, jede konfigurierbare Validierungsregel aus der Datenbank, jede Log-Parsing- oder Routing-Schicht, die Muster aus Konfigurationsdateien baut, die ein Operator (oder ein kompromittierter Mandant) kontrolliert, ist ein Kompilierungspfad, der über feindlichen Input erreichbar ist. Vor dieser Advisory war der schlimmste Fall beim Kompilieren eines feindlichen Musters ein ReDoS: ein Muster mit katastrophalem Backtracking, das eine CPU blockiert. Lästig, aber behebbar. Jetzt ist der schlimmste Fall Speicherkorruption mit RCE-PoCs. Das ist ein kategorial anderes Risiko für dieselbe Codezeile, die du seit Jahren in Produktion hast.

Hier zeigt sich ein Muster, das man benennen sollte: Die Spezifikation sagt das eine, der C-Code das andere, und die Lücke ist ausnutzbar. Wir haben diese Dynamik schon einmal behandelt – die Lücke zwischen Spezifikation und Implementierung ist der Ort, an dem Bugs leben – und Unicodes Case-Folding-Tabellen gehören zu den reichhaltigsten Spezifikationen, die einem C-Programmierer je aufgetragen werden können. Die Tabellen ändern sich zwischen Unicode-Versionen, die Special-Casing-Regeln haben Unterregeln, und wer 2003 den Code zur Puffer-Dimensionierung schrieb, arbeitete mit einem kleineren, einfacheren Unicode als dem, mit dem deine Strings heute ankommen.

Der Integer-Overflow: Aus vier Gigabyte werden sechs Bytes

Der zweite String-Bug ist ein schönes Beispiel für einen anderen Fehlermodus: 32-Bit-Längenarithmetik in einer 64-Bit-Welt. Dieser Proof of Concept, der nach der Advisory öffentlich kursiert, nutzt Shift_JIS und einen String von über vier Gigabyte:

str = ("\x82\xA0" + ("A" * (2**32 + 4))).force_encoding(Encoding::Shift_JIS)
puts "str.bytesize: #{str.bytesize}"   # 4294967302
new_str = str.downcase
puts new_str.bytesize   # 6 on unpatched builds (!)
puts new_str.bytes      # [130, 160, 97, 97, 97, 97]

Ein 4.294.967.302 Byte großer String geht hinein, und das Ergebnis von downcase meldet eine Größe von 6. Irgendwo im Konvertierungspfad wurde eine Länge über einen 32-Bit-Typ berechnet oder gekürzt, 2³² + 6 wurde zu 6 umgebrochen, und die nachfolgende Allokation oder Kopie wurde entsprechend dimensioniert. Das ist eine klassische Pipeline von Integer-Overflow zu Heap-Overflow. Vier Gigabyte klingen nach einer absurden Eingabe, aber denk daran, dass Strings in einem laufenden Prozess nicht in einem Stück über das Netz kommen müssen: Sie werden aus Chunks aufgebaut, durch Dekompression, durch Konkatenation in Importjobs und Dateiparsern. Ein Angreifer, der beeinflussen kann, wie viele Daten sich in einem String ansammeln, und dann downcase darauf auslösen lässt, kontrolliert beide Hälften dieses Bugs.

Beide String-Bugs teilen eine architektonische Lehre mit Alpines zehn Jahre altem Asterisk-Bug: Der gefährliche Code sitzt auf einem Pfad, den niemand als Angriffsfläche betrachtet. Niemand führt ein Threat Modeling für upcase durch. Genau deshalb überleben solche Bugs jahrelang. Sie sitzen in Pfaden, die Menschen nicht prüfen und die Fuzzer bis vor Kurzem nicht mit genug Intelligenz erreichten, um gültige mehrbytige kodierte Strings zu konstruieren.

Maschinen haben diese Bugs gefunden, und das verändert die Rechnung

Schau dir die Danksagungen an. Vier der sieben Advisories danken Stephan Lipp von Ada Logics, der Firma hinter einem großen Teil der Harness-Entwicklung für OSS-Fuzz, und Anthropic. Das ist ein Fuzzing-Infrastruktur-Experte in Kombination mit einem KI-Modell, und es ist nicht die erste Advisory der letzten Zeit mit dieser Signatur. Die Entwicklungslinie lohnt einen Blick: Fuzzing begann 1990 mit Barton Miller, der Unix-Werkzeugen zufälligen Müll fütterte, wurde mit AFLs coverage-geleiteter Mutation 2013 schlauer, wurde mit OSS-Fuzz ab 2016 industrialisiert, das Open-Source-Projekte laufend unter Dauerbeschuss nimmt, und hat jetzt eine Schicht gewonnen, die Code nachvollziehen kann. Ein 4-GiB-Shift_JIS-String oder ein Windows-1252-Puffer, der auf ß endet, erfordert das Verständnis von Encoding-Gültigkeit und Längenarithmetik, nicht bloß das Mutieren von Bytes.

Ein mechanischer Scanner-Arm prüft Lochkarten auf einem Förderband, eine davon leuchtet
Coverage-geleitetes Fuzzing plus das Schlussfolgern von Sprachmodellen prüft alten C-Code schneller, als Menschen es je könnten.

Die strategische Konsequenz wirkt in beide Richtungen. Verteidiger gewinnen kontinuierliche, unermüdliche Prüfung von Codebasen, die sich kein Team leisten könnte, von Hand zu prüfen. Aber dieselbe Fähigkeit steht jedem mit einem Modell und Rechenleistung zur Verfügung, und nicht jeder meldet Advisories. Die bequeme Ära, in der ein Speicherkorruptionsbug in einem obskuren Codepfad Jahre ungestört leben konnte, endet; die Ökonomie des Findens ist eingebrochen. Ich habe schon argumentiert, dass KI-Scanner unsere technische Schuld eintreiben, und das hier ist der Kassenbon: Eine Laufzeitumgebung, die Millionen nutzen, wurde nicht von einem gelangweilten Forscher mit einem freien Wochenende für mangelhaft befunden, sondern von einer automatisierten Pipeline, die einfach weiterlaufen wird.

Meine Position: Das stärkt den Fall für speichersichere Sprachen, aber nicht auf die plumpe Art, wie die Debatte es meist rahmt. Onigmo in Rust neu zu schreiben hätte die Logik nicht repariert. Case-Folding, das die Stringlänge verändert, bleibt ein Gefahrenpunkt auf Spezifikationsebene, und die Frage nach der Puffergröße muss trotzdem korrekt beantwortet werden. Was Speichersicherheit entfernt, ist der Gradient der Konsequenzen. Der Logikfehler wird zu einem Panic, einem falschen Ergebnis, einem fehlgeschlagenen Request, nicht zu RCE. Das ist keine Kleinigkeit; es ist der Unterschied zwischen einem Vorfall und einer Störungsmeldung.

So prüfst du deine eigene Exposition

Fang mit dem Offensichtlichen an und arbeite dich nach außen vor. Aktualisiere auf 4.0.10, 3.4.13 oder 3.3.14. Onigmo ist im Ruby-Build eingebettet, es gibt also keine separate Bibliothek zu patchen; die Laufzeitumgebung ist der Patch. Prüfe dann deinen Anwendungscode auf die beiden gefährlichen Muster: vom Angreifer beeinflusste Strings, die in Case-Operationen fließen, und vom Angreifer beeinflusste Muster, die in Regexp.new oder Regexp.compile fließen.

  • Kompiliere keine Benutzereingaben in Muster. Wenn Nutzer Suchbegriffe eingeben, maskiere sie mit Regexp.escape. Wenn sie wirklich die Macht von Regex brauchen, setze eine Allowlist und ein striktes Timeout davor, und bedenke, dass ein Timeout gegen ReDoS hilft, nicht gegen Speicherkorruption.
  • Normalisiere Encodings an der Vertrauensgrenze. Die beiden String-Bugs hängen an exotischen Encodings (Windows-1252, Shift_JIS). Wenn deine App nur UTF-8 spricht, sag das an den Rändern: Erzwinge oder transkodiere das Encoding beim Eingang und weise ab, was sich nicht sauber konvertieren lässt.
  • Bevorzuge case-insensitiven Vergleich gegenüber Case-Konvertierung. a.casecmp?(b) stellt eine Frage; a.upcase == b.upcase alloziert zwei neue Strings im Encoding, das die Eingabe behauptet. Die Vergleichs-API hat eine deutlich kleinere semantische Oberfläche.
  • Suche in untrusted Daten nach upcase, downcase, swapcase und capitalize. Jeder Aufrufort ist eine Stelle, an der eine Längenannahme lebt. Das gilt ebenso für jede C-Erweiterung, die eigene Case-Logik mitbringt. Die profitieren überhaupt nicht von den Fixes des Core-Teams.
  • Fuzze, was dir gehört. Ruby selbst wird von OSS-Fuzz gefuzzt, deine C-Erweiterungen aber nicht. AFL++ oder libFuzzer mit ASan finden in deinem Code dieselben Bug-Klassen, die Maschinen gerade in Ruby gefunden haben.
  • Kenne den Wartungsstatus deiner Laufzeitumgebung. Ruby 3.2 ist End of Life und hat diese Fixes nicht erhalten. „Es läuft noch“ ist keine Sicherheitsstrategie, wenn der Strom an Patches versiegt ist.

Ein konkretes Vorher-Nachher für das häufigste Muster, das Normalisieren von Benutzernamen oder E-Mail-Adressen für Eindeutigkeitsprüfungen:

# Before: allocates a new string, trusting the input's claimed encoding
def normalize(username)
username.upcase
end
# After: pin the encoding at the boundary, fold for comparison only
def normalize(username)
utf8 = username.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
utf8.downcase(:fold)
end
# And for comparisons, skip allocation entirely:
def same_user?(a, b)
a.encode(Encoding::UTF_8).casecmp?(b.encode(Encoding::UTF_8))
end

Nichts davon macht dich auf einer ungepatchten Laufzeitumgebung sicher, dafür ist das Update da. Aber diese Gewohnheiten verkleinern die Klasse von Bugs, die deine Anwendung von der darunterliegenden Schicht erben kann, und sie machen deinen eigenen Code ehrlich in der Erkenntnis, dass Text nicht gleich Bytes ist.

Vorhängeschlösser auf einer Werkbank, eines davon unter einer Lupe mit feinem Werkzeug
Exposition prüfen: Die Schlösser, die du nicht selbst eingebaut hast, zählen trotzdem als deine.

Die tiefere Lehre für Sprachlaufzeitumgebungen

Man ist versucht, das unter „C ist gefährlich, mehr dazu um elf“ abzuheften, und genau das haben die oberflächlichen Reaktionen auf die Advisory getan. Ich würde weiter gehen. Diese sieben Bugs handeln nicht wirklich von C, sondern vom Missverhältnis zwischen einem sich entwickelnden Internationalisierungsstandard und eingefrorenen Implementierungsannahmen. Unicode wird weiter Schriften hinzufügen und Mappings verfeinern. Jede Sprachlaufzeitumgebung auf der Erde hat Case-Konvertierungscode, der gegen irgendeine frühere Version dieser Tabellen geschrieben wurde und nach einem früheren Verständnis dimensioniert ist, wie stark ein String wachsen kann. Ruby hat es diesen Monat erwischt; als Nächstes wird es die Regex-Engine, der Case-Folder oder die Normalisierungsroutine von jemand anderem treffen.

Die praktische Konsequenz: Behandle Textumwandlung als Sicherheitsgrenze, nicht als Hilfsfunktion. Alles, was neu kodiert, Groß-/Kleinschreibung ändert, normalisiert oder faltet, ist ein Parser, und Parser sind der Ort, an dem Speicherbugs leben. Die historische Konsequenz, die ich als Sprach-Nerd wirklich befriedigend finde, ist, dass das schlichte deutsche ß, mit dem Drucker seit den Zeiten der Fraktur gerungen haben, über sechs Jahrhunderte Typografiegeschichte hinweg immer noch ein Byte hinter das Ende eines Heap-Puffers schreiben kann. Sprache war nie einfach. Wir haben unsere Maschinen nur in dem Glauben gebaut, dass sie es ist.