JSON Toolkit

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.

Advanced~6 min čteníPublikováno 2026-11-11Aktualizováno 2026-11-11
Obálka se dvěma nástroji, které vynášejí opačné verdikty nad stejným JSON dokumentem

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

  1. Srovnejte verze parserů napříč celým řetězcem: jq, runtime, brána, offline validátory — opravy typu CVE-2026-33948 musí dorazit všude;
  2. Explicitně odmítejte duplicitní klíče a NaN: uložte object_pairs_hook a parse_constant do sdílených obálek, nikdy nevolejte json.loads nazí v business kódu;
  3. Rozhodujte o neznámých polích per route: spotřebitelé s dopřednou kompatibilitou je mohou ignorovat, příkazové endpointy musí nastavit RejectUnknownMembers;
  4. 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;
  5. 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ě.

Zdroje

Vhodné nástroje

Související články

Validace JSON v CI: pipeline s jsonlint, ajv a jq

Validace syntaxe dokazuje, že se soubor parsuje; validace schématem dokazuje, že pole odpovídají kontraktu. V CI rozhodují jednoznačné návratové kódy, lokalizace chyb a cesty k opravě.

Středně pokročilý~10 min čteníAktualizováno 2026-10-31

Bezpečnostní kontrolní seznam pro zpracování JSON

`JSON.parse` sám je bezpečný; nebezpečí je v tom, co se stane po něm: hluboké slučování, přiřazení podle cesty, vkládání do HTML, neomezená hloubka a velikost.

Středně pokročilý~12 min čteníAktualizováno 2026-10-30

Čtení hranic gramatiky JSON z RFC 8259

Převod gramatických produkcí RFC 8259 do srozumitelného jazyka – které znaky smějí být přímo, které musí být escapované a kde specifikace záměrně ponechává prostor.

Začátečník~11 min čteníAktualizováno 2026-10-30