Ein JSON, zwei Urteile: Parser-Unterschiede und die Vertrauensgrenze der Validierung
Fazit: Wenn ein Validator ein Dokument akzeptiert und der Downstream-Service abstürzt, haben meist zwei Parser über denselben Text unterschiedlich entschieden. Dieser Artikel testet doppelte Schlüssel, NUL-Bytes, ungültiges UTF-8, NaN und führende Nullen gegen echte Laufzeiten, erklärt, wie CVE-2026-33948 aus Parser-Unterschieden eine Angriffsfläche macht, und zeigt, wie jede Grenze einen einzigen Schiedsrichter bekommt.

Eine bestandene Validierung beweist genau eine Sache: Der Text wurde von diesem Parser unter dieser Richtlinie akzeptiert. Tauscht man den Parser, kann das Urteil kippen.
Das Symptom: Werkzeug A akzeptiert, Werkzeug B lehnt ab
Jeder kennt die Szene. Eine API-Antwort, in einen Online-Formatter eingefügt, zeigt einen grünen Haken. Dieselbe Nutzlast erreicht den Downstream-Service und wirft eine Ausnahme. Stellt man beide Parser nebeneinander und vergleicht Zeichen für Zeichen, hat meist niemand „Fehler gemacht" — die Daten sind exakt auf einem Punkt gelandet, an dem die beiden Implementierungen auseinanderlaufen.
Solche Punkte gibt es wenige, aber jeder ist häufig. Die folgende Tabelle hält das reale Verhalten häufiger Eingaben fest (getestet mit JSON.parse aus Node 22, json aus der Python-Standardbibliothek 3.11, jq 1.8 und gängigen Online-Validierern):
| Eingabe | Node JSON.parse | Python json.loads | jq | Anmerkung |
|---|---|---|---|---|
{"a":1,"a":2} doppelter Schlüssel |
akzeptiert, letzter Wert bleibt | akzeptiert, letzter Wert bleibt | akzeptiert, letzter Wert bleibt | RFC 8259 sagt nur SHOULD; alle vier lassen es durch |
{"n":NaN} |
Fehler | akzeptiert | Fehler | Die Python-Standardbibliothek erlaubt es standardmäßig — die größte stille Falle |
{"n":01} führende Null |
Fehler | Fehler | Fehler | Einheitlich abgelehnt, aber Fehlerpositionen unterscheiden sich |
"Text" als GBK-Bytes gespeichert |
Fehler oder Zeichensalat | je nach Kodierungsangabe | Fehler | RFC verlangt UTF-8; das Dekodieren gehört zur IO-Schicht |
{"a":1} mit vorangestelltem BOM |
Fehler | akzeptiert (utf-8-sig) | Fehler | Wer das BOM entfernt, entscheidet |
| Kommentare, einfache Anführungszeichen, Schlusskomma | Fehler | Fehler | Fehler | Nur JSON5-/JSONC-Parser akzeptieren sie |
Ein Blick auf Zeile zwei: json.loads('{"cpu":NaN}') ist in Python legal. Die Standardbibliothek akzeptiert NaN/Infinity bewusst aus Kompatibilitätsgründen, und viele Pipelines haben diese Schrottzeilen als normale Datensätze in Statistiken eingebracht, ohne die Kontamination zu bemerken. Blockieren erfordert ein explizites parse_constant — Code unten.
Woher die Unterschiede kommen: Lücken der Spezifikation
RFC 8259 ist nicht unklar; er lässt absichtlich drei Bereiche „der Implementierung überlassen", und jede Implementierung füllt sie anders.
Erstens die Eindeutigkeit von Namen. Abschnitt 4 sagt, Namen SOLLTEN eindeutig sein — eine Empfehlung, keine Regel. Ein doppelter Schlüssel ist also kein Syntaxfehler, und Parser überall wählen „der Letzte gewinnt". Der Geschäftsvalidator sieht nur den überlebenden Wert; der zuerst geschriebene verschwindet ohne Fehler und ohne Logzeile.
Zweitens Zahlen. Die Grammatik fixiert nur die Form int frac exp; die Größenordnung überlässt sie der Implementierung. JavaScript presst alles durch IEEE-754-Doubles, sodass 9007199254740993 zu ...992 wird. jq bewahrt Dezimalliterale seit 1.8 treu, aber jede Rechnung fällt aufs Double zurück. Dasselbe Dokument kann beim Vergleichen, Speichern und Übertragen drei verschiedene Werte annehmen.
Drittens UTF-8 und unsichtbare Zeichen. Die Spezifikation verlangt, dass ausgetauschtes JSON UTF-8 ist, aber wie eine Datei geöffnet wird, ob ein BOM entfernt wird und wie ungültige Bytes behandelt werden, entscheidet die IO-Schicht. Derselbe Bytestrom liefert je nach utf-8 oder utf-8-sig in Python unterschiedliche Urteile.
Eine vierte Quelle sind nachsichtige Dialekte. JSON5 erlaubt Kommentare, einfache Anführungszeichen und Schlusskommas; JSONC lockert dieselben Regeln im VS-Code-Ökosystem. Konfigurationsdateien mit einem laxen Parser und APIs mit einem strengen — das ist die häufigste Spaltung innerhalb eines Teams.
CVE-2026-33948: Aus Unterschieden wird eine Angriffsfläche
Parser-Unterschiede sind gewöhnlich ein Komfortproblem. Sobald „Validierung" und „Parsen" auf zwei verschiedenen Implementierungen laufen, werden sie zur Angriffsfläche. CVE-2026-33948, 2026 offengelegt, ist ein Lehrbuchfall: jq vor 1.8.2 erlaubte beim Lesen von JSON aus Dateien eingebettete NUL-Bytes (\0), sodass dieselbe Eingabe zwei Urteile erhielt — die Validierungsstufe hielt den Inhalt dort für beendet, während die tatsächliche Verarbeitung weiterlas. Die Umgehung steht. Der GitHub-Sicherheitshinweis bestätigt die Korrektur: Upgrade auf 1.8.2.
Verallgemeinert: In jeder Kette „erst validieren, dann parsen" kann ein Angreifer, wenn beide Schritte unterschiedliche Implementierungen oder Konfigurationen nutzen, eine Eingabe bauen, die der Validator verwirft und der Parser akzeptiert — und so eine böswillige Nutzlast vorbeischmuggeln. Dieselbe Struktur gilt auf Gateway-Ebene. API7s Argument, strenges Parsen in den API-Vertrag zu schreiben: Parse-Semantik ist Teil des Vertrags, nicht das Privatverhalten einer Implementierung.
Die Selbstprüfung besteht aus einem Befehl — prüfen, dass jede Stufe dieselbe jq-Version mit dieser Korrektur nutzt:
jq --version
# jq-1.7.1 ← verwundbar, Upgrade nötig
# jq-1.8.2 ← korrigiert
Doppelte Schlüssel: der letzte Wert wird still verschluckt
Doppelte Schlüssel verdienen einen eigenen Abschnitt, weil sie die eine Grenze sind, die jeder gängige Parser akzeptiert, während fast jeder Entwickler einen Fehler erwartet.
import json
text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data) # {'role': 'admin'}
print("guest" in data.values()) # False: der erste Wert ist weg
Speist dieser Text eine Signaturprüfung oder eine Rechtestruktur, kann ein Angreifer ein gleichnamiges Feld anhängen und das Recht überschreiben; der Validierungscode sieht nur den Endwert. JSON.parse in Node verhält sich identisch. Zum Erkennen statt stillen Überschreiben akzeptiert Python einen object_pairs_hook:
from collections import Counter
def reject_dup(pairs):
counts = Counter(k for k, _ in pairs)
dup = [k for k, c in counts.items() if c > 1]
if dup:
raise ValueError(f"duplicate keys: {dup}")
return dict(pairs)
data = json.loads('{"a":1,"a":2}', object_pairs_hook=reject_dup)
# ValueError: duplicate keys: ['a']
RFC 8259, Abschnitt 4, sagt es ungeschminkt: Für Interoperabilität SOLLTEN Namen eindeutig sein. Diesen SHOULD zur Validierungsregel zu erheben kostet einen Durchlauf und beseitigt die häufigste Quelle von „zwei Werkzeugen, zwei Urteilen".
Die Korrektur: jeder Grenze einen einzigen Schiedsrichter zuweisen
Die Reparatur ist nicht „auf einen strengeren Parser wechseln". Sie besteht darin, jeder Grenze eine explizite, schriftliche Richtlinie zu geben — und sicherzustellen, dass Validierung und Ausführung dieselbe nutzen. Die folgende Tabelle taugt als Review-Checkliste:
| Grenze | Nachsichtiges Standardverhalten | Empfohlenes Urteil | Repräsentative Konfiguration |
|---|---|---|---|
| doppelte Schlüssel | letzter Wert überschreibt | ablehnen | Python object_pairs_hook; Go json/v2 lehnt standardmäßig ab |
| NaN / Infinity | Python akzeptiert | ablehnen | Python parse_constant mit Exception |
| unbekannte Felder | still ignoriert | je nach Vertrag entscheiden | Go json/v2 RejectUnknownMembers(true) |
| ungültiges UTF-8 | je nach Implementierung | ablehnen | explizite Bytestrom-Validierung in der Dekodierschicht |
| BOM | wer es entfernt, entscheidet | einmal am Eingang entfernen | festes utf-8-sig oder vorheriges Entfernen |
| Validierung und Ausführung getrennt | jeder seine eigene | eine Implementierung, eine Konfiguration | Validatoren nutzen den Produktions-Parser |
In Python genügt ein Aufruf, um die zwei gefährlichsten Standardwerte auszuschalten:
import json
def _reject(value):
raise ValueError(f"non-standard constant: {value}")
data = json.loads(
raw,
parse_constant=_reject, # blockiert NaN / Infinity
object_pairs_hook=reject_dup, # blockiert doppelte Schlüssel
)
encoding/json/v2 in Go (alias jsonv2) macht die ganze Richtlinie explizit: RejectUnknownMembers(true) lehnt unbekannte Felder ab, und doppelte Namen sowie ungültiges UTF-8 werden standardmäßig abgelehnt. Die Praxisseite von GopherForge ist präzise zur Reihenfolge: Eingabebytes begrenzen, unter einer expliziten Richtlinie dekodieren, Domäne validieren und autorisieren — und erst dann Seiteneffekte erlauben. Jeder Fehlerpfad muss mit Fixtures durchprobt sein, nicht anhand einer veränderten Fehlermeldung beurteilt werden.
Die Parse-Richtlinie in Verträge und Korpora verankern
Die Richtlinie braucht Schutz vor Drift. Zwei Aktionen genügen.
Erstens: „Was wir akzeptieren, was wir ablehnen" in die Schnittstellendokumentation schreiben, neben den Felddefinitionen. API7 empfiehlt einen stabilen Fehlercode, damit Clients eine dauerhafte Vertragsverletzung von einem vorübergehenden Infrastrukturfehler unterscheiden können — ein abgelehnter doppelter Schlüssel darf nicht wie ein Gateway-Timeout aussehen, sonst löst man eine Retry-Welle aus. Den vollen Anfragetext nicht in Logs zurückspielen: Rohe Nutzdaten können Zugangsdaten enthalten, manche ungültige Bytefolgen sind auch beim Drucken riskant.
Zweitens: ein Ambiguitätskorpus aufbauen. Jede Zeile der Tabelle oben wird zum Testfall: doppelte Schlüssel, in Groß-/Kleinschreibung verschiedene Schlüssel, unbekannte Felder, ungültiges UTF-8, BOM, ein zusätzlicher Wert am Ende, leere Eingabe. In CI zwei Behauptungen: ungültige Eingaben scheitern, ohne einen brauchbaren Teilwert zu erzeugen; akzeptierte Eingaben überstehen eine Encode/Decode-Runde unverändert. Bei jedem Parser-Upgrade Produktionsform-Proben in einer geschützten Umgebung im Vergleichsmodus abspielen und die Änderung der Akzeptanzmenge als echte Vertragsänderung begutachten — nicht annehmen, dass alte Fixtures noch alles abdecken.
Diese Aktionen ergänzen JSON-Validierung in CI: jsonlint, ajv und jq, das die Einordnung von Syntax- und Schema-Validierung in die Pipeline behandelt; dieser Artikel behandelt, was vor dem ersten Knoten kommt — den Parser selbst. Injektionsrisiken wie Prototypenverschmutzung und XSS deckt die JSON-Sicherheitsrisiken-Liste ab; Vertrauenskettenprobleme auf Parser-Ebene wie doppelte Schlüssel und NUL-Bytes sind genau Schicht null dieser Liste. Zur Lokalisierung reiner Syntaxfehler siehe JSON-Grammatikgrenzen aus RFC 8259.
Eine Checkliste vor dem Livegang
- Parser-Versionen über die ganze Kette angleichen: jq, Laufzeiten, Gateway, Offline-Validierer einzeln per
--versionprüfen; Fixes wie CVE-2026-33948 müssen überall ankommen; - Doppelte Schlüssel und NaN explizit ablehnen:
object_pairs_hookundparse_constantin gemeinsame Wrapper legen, nacktejson.loads-Aufrufe im Geschäftscode verbieten; - Unbekannte Felder pro Route entscheiden: abwärtskompatible Konsumenten dürfen ignorieren, Befehls-Endpunkte müssen
RejectUnknownMemberssetzen; - Ambiguitätskorpus in die CI: mindestens 8 Fixtures, plus Alt-Neu-Vergleich vor jedem Upgrade;
- Klassifizierbare Fehler: eigene Codes für Vertrags- und Infrastrukturfehler, Retries nur für Letztere.
Zurück zum Einstiegssatz: Eine bestandene Validierung bedeutet „von irgendeinem Parser unter irgendeiner Richtlinie akzeptiert". Macht man diese Richtlinie explizit — in den Vertrag, in den Korpus, ins Versions-Pinning —, verschwindet „ein JSON, zwei Urteile" endgültig.
FAQ
Sind doppelte Schlüssel in der JSON-Spezifikation wirklich kein Fehler?
Kein Syntaxfehler. RFC 8259, Abschnitt 4, formuliert SHOULD be unique — eine Empfehlung, keine Pflicht —, daher akzeptieren die großen Parser Duplikate und behalten standardmäßig den letzten Wert. Für Interoperabilität wird Eindeutigkeit empfohlen. Ob man das zur Validierungsregel erhebt, entscheidet der Vertrag; die Erkennung kostet einen einzigen Durchlauf.
Warum akzeptiert Pythons json-Bibliothek NaN, während JavaScript einen Fehler wirft?
Pythons Standardbibliothek akzeptiert NaN und Infinity bewusst, um eigene historisch verlustbehaftete Ausgaben wiederlesen zu können. JSON.parse in ECMAScript implementiert die Grammatik streng und wirft bei NaN eine SyntaxError. Mit parse_constant lehnt Python sie ab, und eine Zeile Konfiguration richtet beide Laufzeiten aus.
Welche Versionen betreffen CVE-2026-33948, und wie wird sie behoben?
jq vor 1.8.2 akzeptiert beim Lesen von JSON aus Dateien eingebettete NUL-Bytes, sodass Validierungsstufe und tatsächlicher Parser über dieselbe Eingabe unterschiedlich entscheiden und eine Validierungsumgehung entsteht. Laut GitHub-Hinweis ist die Korrektur das Upgrade auf 1.8.2 oder einen Build ab Commit 6374ae0. In Skripten und CI die Version pinnen und vor Upgrades den Ambiguitätskorpus ausführen.
Ich validiere einmal am Eingang und verwende das Ergebnis weiter — bin ich trotzdem exponiert?
Ja, aber das Risiko konzentriert sich auf diesen einen Punkt. Sind Eingangs-Parser, Konfiguration und Version fixiert und deckt der Korpus doppelte Schlüssel, NUL und UTF-8 ab, gibt es keinen zweiten Schiedsrichter in der Kette. Gefährlich ist die Topologie „Gateway auf einer Implementierung, Services auf einer anderen" oder „Validierung mit A, Ausführung mit B" — sie übergibt das Urteil dem Dissens selbst.