Jeden JSON, dva verdikty: rozdíly parserů a hranice důvěry validace
Shrnutí: Když validátor dokument přijme a následující služba spadne, obvykle se dva parsery neshodly na stejném textu. Článek porovnává duplicitní klíče, NUL bajty, neplatné UTF-8, NaN a úvodní nuly na reálných runtimech, vysvětluje, jak CVE-2026-33948 proměnilo neshodu v útočnou plochu, a ukazuje, jak přiřadit jediného rozhodčího každé hranici.

Procházející validace dokazuje právě jednu věc: text byl přijat tímto parserem za této politiky. Vyměňte parser a verdikt se může překlopit.
Příznak: nástroj A schvaluje, nástroj B odmítá
Scénu, kterou potkal každý. Odpověď API vložíte do online formátovače a dostanete zelenou fajfku. Stejný payload dorazí do následující služby a ta vyhodí výjimku. Když postavíte oba parsery vedle sebe a porovnáte znak po znaku, obvykle žádná strana „nemylila“ — data dopadla přesně na bod, kde se obě implementace rozcházejí.
Těchto bodů není mnoho, ale každý je častý. Následující tabulka zaznamenává reálné chování u častých vstupů (testováno proti Node 22 JSON.parse, standardnímu json v Pythonu 3.11, jq 1.8 a běžným online validátorům):
| Vstup | Node JSON.parse | Python json.loads | jq | Poznámka |
|---|---|---|---|---|
{"a":1,"a":2} duplicitní klíč |
přijme, zůstane poslední | přijme, zůstane poslední | přijme, zůstane poslední | RFC 8259 říká jen SHOULD; všichni čtyři to pustí |
{"n":NaN} |
chyba | přijme | chyba | Standardní knihovna Pythonu to ve výchozím stavu přijímá — největší tichá past |
{"n":01} úvodní nula |
chyba | chyba | chyba | Odmítáno všude, ale pozice chyb se liší |
"中文" uloženo jako bajty GBK |
chyba nebo rozsypaný čaj | závisí na kódování | chyba | RFC vyžaduje UTF-8, ale dekódování patří vrstvě IO |
{"a":1} s BOM |
chyba | přijme (utf-8-sig) | chyba | Rozhoduje ten, kdo BOM odstraní |
| komentáře, jednoduché uvozovky, koncové čárky | chyba | chyba | chyba | Přijímají je jen parsery JSON5/JSONC |
Podívejte se na druhý řádek: json.loads('{"cpu":NaN}') je v Pythonu legální. Standardní knihovna přijímá NaN/Infinity záměrně kvůli zpětné kompatibilitě a mnoho pipeline počítalo tyto smetí jako běžné záznamy, aniž si všimlo zamoření. Zablokovat je vyžaduje explicitní argument parse_constant — kód níže.
Odkud rozdíly pocházejí: mezery ve specifikaci a rozhodnutí implementací
RFC 8259 není vágní; tři oblasti záměrně nechává „na implementaci“ a každá implementace je vyplní po svém.
Zaprvé, jednoznačnost názvů objektů. Sekce 4 říká, že názvy BY MĚLY být unikátní — doporučení, ne pravidlo. Duplicitní klíč tedy není syntaktická chyba a parsery všude volí „vyhrává poslední“. Business validátor pak vidí jen přeživší hodnotu; hodnota, kterou odesílatel poslal první, zmizela bez chyby i bez řádku logu.
Zadruhé, čísla. Gramatika stanovuje jen tvar int frac exp; velikost nechává na implementaci. JavaScript vše protlačí IEEE 754 double, takže 9007199254740993 se změní na ...992. jq od 1.8 uchovává desetinné literály věrně, ale jakákoli aritmetika spadne zpět do double. Tentýž dokument může ukazovat tři různé hodnoty při porovnávání, ukládání a přenosu.
Zatřetí, UTF-8 a neviditelné znaky. Specifikace vyžaduje, aby vyměňovaný JSON byl v UTF-8, ale jak se soubor otevře, zda se odstraní BOM a co se stane s neplatnými bajty, jsou rozhodnutí vrstvy IO. Tentýž proud bajtů dává různé verdikty podle toho, zda ho Python otevře jako utf-8 nebo utf-8-sig.
Čtvrtým zdrojem jsou tolerantní dialekty. JSON5 připouští komentáře, jednoduché uvozovky a koncové čárky; JSONC uvolňuje stejná pravidla v ekosystému VS Code. Konfigurace parsovaná shovívavým parserem a API parsovaná striktním je nejčastější rozpor uvnitř jednoho týmu.
CVE-2026-33948: když se neshoda stane útočnou plochou
Rozdíly parserů bývají jen nepříjemností pro uživatele. Jakmile „validace“ a „parsování“ běží na dvou různých implementacích, stávají se útočnou plochou. CVE-2026-33948, zveřejněné v roce 2026, je učebnicový případ: jq ve verzích před 1.8.2 připouštěl vložené NUL bajty (\0) při čtení JSON ze souborů, takže tentýž vstup vedl ke dvěma verdiktům — fáze validace považovala obsah za tam skončený, zatímco skutečné zpracování četlo dál. Obchvat je kompletní. Bezpečnostní poradenství GitHubu potvrzuje opravu: přejít na 1.8.2.
Poučení: v jakékoli řetězci „nejprve validovat, pak parsovat“, pokud oba kroky používají různé implementace či konfigurace, může útočník zkonstruovat vstup, který validátor odmítne a parser přijme, a propašovat payload kolem kontroly. Stejná struktura se opakuje na bráně — argument API7 pro zapsání striktního parsování do kontraktu API je, že sémantika parsování je součástí kontraktu, ne soukromým chováním implementace. Když brána odmítne požadavek podle jedné sady pravidel a backendová služba přijme totéž tělo jiným parserem, kontrakt se už rozbil.
Sebekontrola se vejde do jednoho příkazu — ověřte, že všechny fáze používají stejnou verzi jq včetně této opravy:
jq --version
# jq-1.7.1 ← zranitelné, aktualizovat
# jq-1.8.2 ← opraveno
Duplicitní klíče: poslední hodnota potichu pohltí první
Duplicitní klíče si zaslouží vlastní sekci, protože jsou to jediná hranice, kterou všechny běžné parsery přijímají, zatímco téměř každý vývojář předpokládá chybu.
import json
text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data) # {'role': 'admin'}
print("guest" in data.values()) # False: první hodnota je pryč
Pokud takový text vstupuje do kontroly podpisu nebo rozhodnutí o oprávněních, útočník může přidat stejnojmenné pole a přepsat oprávnění a váš validční kód uvidí jen finální hodnotu. JSON.parse v Node se chová stejně. Aby se detekovalo místo tichého přepsání, Python nabízí 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']
Sekce 4 RFC 8259 to říká přímo: pro interoperabilitu BY MĚLY být názvy unikátní. Povýšit to SHOULD na pravidlo validace stojí jeden průchod a odstraňuje nejčastější zdroj „dvou nástrojů, dvou verdiktů“.
Řešení: jeden rozhodčí pro každou hranici
Oprava není „přejít na striktnější parser“. Jde o to dát každému hraničnímu bodu explicitní, zapsanou politiku — a zajistit, aby validace i vykonávání používaly tutéž. Následující tabulka poslouží jako revizní checklist:
| Hranice | Shovívavý výchozí stav | Doporučený verdikt | Reprezentativní konfigurace |
|---|---|---|---|
| duplicitní klíče | vyhrává poslední | odmítnout | object_pairs_hook v Pythonu; json/v2 v Go odmítá ve výchozím stavu |
| NaN / Infinity | Python přijímá | odmítnout | parse_constant v Pythonu vyhazující výjimku |
| neznámé položky | tiše ignorovány | rozhodnout dle kontraktu | RejectUnknownMembers(true) v json/v2 Go |
| neplatné UTF-8 | liší se dle implementace | odmítnout | explicitní validace bajtového proudu ve dekódovací vrstvě |
| BOM | rozhoduje ten, kdo jej odstraní | odstranit jednou na vstupu | fixní utf-8-sig nebo odstranění před parsováním |
| validace a vykonávání odděleny | každý sám za sebe | jedna implementace, jedna konfigurace | validátory znovu používají produkční parser |
Na straně Pythonu stojí vypnutí dvou nejnebezpečnějších výchozích nastavení jedno volání:
import json
def _reject(value):
raise ValueError(f"non-standard constant: {value}")
data = json.loads(
raw,
parse_constant=_reject, # blokuje NaN / Infinity
object_pairs_hook=reject_dup, # blokuje duplicitní klíče
)
encoding/json/v2 v Go (pod aliasem jsonv2) činí celou politiku explicitní: RejectUnknownMembers(true) odmítá neznámá pole a duplicitní názvy spolu s neplatným UTF-8 se odmítají ve výchozím stavu. Stránka postupů GopherForge je přesná v pořadí: ohraničte vstupní bajty, dekódujte podle explicitní politiky, validujte doménu a autorizujte — a teprve pak dovolejte vedlejší efekty; každá chybová cesta se musí projít na fixturách, nesmí se soudit podle změněného chybového řetězce.
Zapište politiku parsování do kontraktů a korpusů
Politika potřebuje ochranu před driftováním. Stačí dvě akce.
Zaprvé, zapište „co přijímáme, co odmítáme“ do rozhraní dokumentace vedle definic polí. API7 doporučuje stabilní chybový kód, aby klienti rozlišili trvalou kontraktovou chybu od přechodného výpadku infrastruktury — odmítnutý duplicitní klíč nesmí vypadat jako timeout brány, jinak zváte vlnu opakování. Do logů nevypisujte celé tělo požadavku: surové payloady mohou obsahovat přihlašovací údaje a některé neplatné bajtové sekvence se nebezpečně zobrazují.
Zadruhé, postavte korpus dvojznačností. Proměňte každý řádek tabulky výše v testovací fixturu: duplicitní klíče, klíče v různé velikosti písmen, neznámé položky, neplatné UTF-8, BOM, druhá hodnota na konci, prázdný vstup. V CI tvrdte dvě věci: neplatné vstupy selžou, aniž by vytvořily použitelnou částečnou hodnotu, a přijaté projdou kódováním a dekódováním beze změny. Při upgradu parseru přehrajte produkční vzorky v chráněném prostředí v porovnávacím režimu a změnu v přijímací sadě revidujte jako skutečnou změnu kontraktu, namísto předpokladu, že staré fixtury pokryjí vše.
Tyto akce doplňují Validace JSON v CI: pipeline jsonlint, ajv a jq, která popisuje, jak se syntaktická a schémová validace vkládají do pipeline; tento článek pokrývá to, co předchází prvnímu uzlu — samotný parser. Injekční rizika jako prototype pollution a XSS rozebírá kontrolní seznam bezpečnostních rizik JSON; problémy řetězce důvěry na úrovni parseru — duplicitní klíče a NUL bajty — jsou přesně nultou vrstvou toho seznamu. Pro hledání prostých syntaktických chyb viz Hranice JSON gramatiky dle RFC 8259.
Checklist před nasazením
- Srovnejte verze parserů napříč celým řetězcem: jq, runtime, brána, offline validátory — opravy typu CVE-2026-33948 musí dorazit všude;
- Explicitně odmítejte duplicitní klíče a NaN: uložte
object_pairs_hookaparse_constantdo sdílených obálek, nikdy nevolejtejson.loadsnazí v business kódu; - Rozhodujte o neznámých polích per route: spotřebitelé s dopřednou kompatibilitou je mohou ignorovat, příkazové endpointy musí nastavit
RejectUnknownMembers; - Korpus dvojznačností v CI: alespoň 8 fixtur plus porovnávací běh starého proti novému před každým upgradem parseru;
- Tříditelné chyby: odlišné kódy pro kontraktové a infrastrukturní selhání, opakujte jen ty druhé.
Vraťme se k úvodní větě: projít validací znamená „přijato nějakým parserem za nějaké politiky“. Udělejte tuto politiku explicitní — do kontraktu, do korpusu, do ukotvení verzí — a „jeden JSON, dva verdikty“ konečně zmizí.
FAQ
Jsou duplicitní klíče podle specifikace JSON skutečně chybou?
Nejsou syntaktickou chybou. Sekce 4 RFC 8259 to formuluje jako „názvy BY MĚLY být unikátní“ — doporučení, ne požadavek — takže hlavní parsery duplikáty přijímají a ve výchozím stavu ponechávají poslední hodnotu. Specifikace unikátnost pro interoperabilitu doporučuje. Povýšit ji na chybu validace je rozhodnutí kontraktu; detekce stojí jeden průchod.
Proč json knihovna v Pythonu přijímá NaN, zatímco JavaScript hází chybu?
Standardní knihovna Pythonu přijímá NaN a Infinity záměrně, aby uměla znovu číst data, která historicky vypouštěla se ztrátou. JSON.parse v ECMAScriptu implementuje gramatiku striktně a hází SyntaxError. Předáním parse_constant v Pythonu je odmítnete a jedna řádku konfigurace srovná oba runtime.
Kterých verzí se týká CVE-2026-33948 a jak se opravuje?
jq před 1.8.2 při čtení JSON ze souborů přijímá vložené NUL bajty, kvůli nimž se fáze validace a skutečný parser rozcházejí na témže vstupu, což umožňuje obejití validace. Oprava dle poradenství GitHubu je přejít na 1.8.2 nebo na build obsahující commit 6374ae0. Ukotvěte verze ve skriptech a CI a před upgradem pusťte korpus dvojznačností.
Validuji jednou na vstupu a výsledek znovu používám — jsem stále ohrožen?
Ano, ale riziko se soustředí do té jediné vstupní brány. Pokud je vstupní parser, jeho konfigurace i verze ukotveny a korpus dvojznačností pokrývá duplicitní klíče, NUL bajty a UTF-8, druhý rozhodčí uvnitř řetězce není. Nebezpečná topologie je brána na jedné implementaci a služby na druhé, nebo validace na jednom parseru a vykonávání na jiném — tehdy verdikt předáte samotné neshodě.