JSON Toolkit

Jeden JSON, dwa werdykty: różnice parserów i granica zaufania walidacji

Podsumowanie: Gdy walidator akceptuje dokument, a kolejna usługa się wysypuje, zwykle dwa parsery rozjechały się co do tego samego tekstu. Artykuł porównuje zduplikowane klucze, bajty NUL, niepoprawne UTF-8, NaN i zera wiodące na realnych runtime'ach, wyjaśnia, jak CVE-2026-33948 zamieniło rozbieżność w powierzchnię ataku, i pokazuje, jak przypisać jednego arbitra każdej granicy.

Advanced~6 min czytaniaOpublikowano 2026-11-11Zaktualizowano 2026-11-11
Okładka z dwoma narzędziami wydającymi przeciwne werdykty o tym samym dokumencie JSON

Zaliczenie walidacji dowodzi dokładnie jednego: tekst został zaakceptowany przez ten parser, przy tej polityce. Zmień parser — a werdykt może się odwrócić.

Objaw: narzędzie A przepuszcza, narzędzie B odrzuca

Scena, którą zna każdy. Odpowiedź API wklejasz do internetowego formatowacza i dostajesz zielony ptaszek. Ten sam payload dociera do kolejnej usługi i leci wyjątek. Gdy postawisz oba parsery obok siebie i porównasz znak po znaku, zwykle żadna ze stron nie jest „w błędzie" — dane wylądowały dokładnie w punkcie, w którym dwie implementacje się rozjeżdżają.

Takich punktów nie ma wielu, ale każdy jest częsty. Poniższa tabela rejestruje rzeczywiste zachowanie przy częstych wejściach (przetestowane na Node 22 JSON.parse, standardowym json w Pythonie 3.11, jq 1.8 i popularnych walidatorach online):

Wejście Node JSON.parse Python json.loads jq Uwagi
{"a":1,"a":2} zduplikowany klucz akceptuje, zostaje ostatni akceptuje, zostaje ostatni akceptuje, zostaje ostatni RFC 8259 mówi tylko SHOULD; wszystkie cztery przepuszczają
{"n":NaN} błąd akceptuje błąd Biblioteka standardowa Pythona akceptuje domyślnie — największa cicha pułapka
{"n":01} zero wiodące błąd błąd błąd Odrzucane wszędzie, ale pozycje błędów się różnią
"中文" zapisane jako bajty GBK błąd lub krzaczki zależy od kodowania błąd RFC wymaga UTF-8, ale dekodowanie to warstwa IO
{"a":1} z BOM błąd akceptuje (utf-8-sig) błąd Decyduje ten, kto zdejmuje BOM
komentarze, apostrofy, przecinki końcowe błąd błąd błąd Akceptują je tylko parsery JSON5/JSONC

Spójrz na drugi wiersz: json.loads('{"cpu":NaN}') jest w Pythonie legalne. Biblioteka standardowa celowo akceptuje NaN/Infinity dla wstecznej zgodności, i wiele pipeline'ów liczyło te śmieciowe linie jako zwykłe rekordy, nie zauważając zakażenia. Zablokowanie ich wymaga jawnego argumentu parse_constant — kod niżej.

Skąd biorą się różnice: luki w specyfikacji i decyzje implementacji

RFC 8259 nie jest niejasny; świadomie zostawia trzy obszary „implementacji", a każda implementacja wypełnia je po swojemu.

Po pierwsze, unikalność nazw obiektów. Sekcja 4 mówi, że nazwy POWINNY być unikalne — to zalecenie, nie reguła. Zduplikowany klucz nie jest więc błędem składni, a parsery wszędzie wybierają „wygrywa ostatni". Walidator biznesowy widzi wtedy tylko ocalałą wartość; wartość, którą nadawca wysłał jako pierwszą, zniknęła bez błędu i bez linijki logu.

Po drugie, liczby. Gramatyka ustala tylko kształt int frac exp; wielkość zostawia implementacji. JavaScript przepuszcza wszystko przez double IEEE 754, więc 9007199254740993 zamienia się w ...992. jq od 1.8 wiernie zachowuje literały dziesiętne, ale każda arytmetyka wraca do double'ów. Ten sam dokument może pokazywać trzy różne wartości przy porównaniu, zapisie i transporcie.

Po trzecie, UTF-8 i niewidzialne znaki. Specyfikacja wymaga, by wymieniany JSON był w UTF-8, ale jak otwierany jest plik, czy zdejmuje się BOM i co dzieje się z niepoprawnymi bajtami — to decyzje warstwy IO. Ten sam strumień bajtów daje różne werdykty w zależności od tego, czy Python otworzy go jako utf-8, czy utf-8-sig.

Czwartym źródłem są pobłażliwe dialekty. JSON5 dopuszcza komentarze, apostrofy i przecinki końcowe; JSONC rozluźnia te same reguły w ekosystemie VS Code. Konfiguracja parsowana pobłażliwym parserem i API parsowane ścisłym — to najczęstsza rozbieżność wewnątrz jednego zespołu.

CVE-2026-33948: gdy rozbieżność staje się powierzchnią ataku

Różnice parserów to zwykle irytacja UX. Gdy tylko „walidacja" i „parsowanie" działają na dwóch różnych implementacjach, stają się powierzchnią ataku. CVE-2026-33948, ujawnione w 2026 roku, to podręcznikowy przypadek: jq w wersjach przed 1.8.2 dopuszczał wstawione bajty NUL (\0) przy czytaniu JSON z plików, więc to samo wejście dawało dwa werdykty — etap walidacji traktował zawartość jako zakończoną w tym miejscu, a faktyczne przetwarzanie czytało dalej. Ominięcie kompletne. Zalecenie bezpieczeństwa GitHuba potwierdza poprawkę: aktualizacja do 1.8.2.

Wyciągnij wniosek: w każdym łańcuchu „najpierw waliduj, potem parsuj", jeśli oba kroki używają różnych implementacji lub konfiguracji, atakujący może skonstruować wejście, które walidator odrzuci, a parser przyjmie, przemyciając payload obok kontroli. Ta sama struktura powtarza się na bramie — argument API7 za wpisaniem ścisłego parsowania do kontraktu API jest taki, że semantyka parsowania jest częścią kontraktu, nie prywatnym zachowaniem implementacji. Gdy brama odrzuca żądanie według jednego zestawu reguł, a serwis backendowy przyjmuje to samo ciało innym parserem, kontrakt już się rozpadł.

Samokontrola mieści się w jednej komendzie — upewnij się, że wszystkie etapy używają tej samej wersji jq, w tym tej poprawki:

jq --version
# jq-1.7.1  ← podatne, aktualizuj
# jq-1.8.2  ← poprawione

Zduplikowane klucze: ostatnia wartość cicho połyka pierwszą

Zduplikowane klucze zasługują na własną sekcję, bo to jedyna granica, którą wszystkie popularne parsery akceptują, choć prawie każdy deweloper zakłada, że to błąd.

import json

text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data)          # {'role': 'admin'}
print("guest" in data.values())  # False: pierwszej wartości już nie ma

Jeśli ten tekst zasila sprawdzenie podpisu albo decyzję o uprawnieniach, atakujący może dodać pole o tej samej nazwie i nadpisać uprawnienie, a Twój kod walidacji zobaczy tylko wartość końcową. JSON.parse w Node zachowuje się identycznie. By wykrywać zamiast cicho nadpisywać, Python przyjmuje 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']

Sekcja 4 RFC 8259 mówi wprost: dla interoperacyjności nazwy POWINNY być unikalne. Podniesienie tego SHOULD do reguły walidacji kosztuje jeden przebieg i usuwa najczęstsze źródło „dwóch narzędzi, dwóch werdyktów".

Rozwiązanie: jeden arbiter na każdą granicę

Naprawa nie polega na „przejściu na ściślejszy parser". Chodzi o to, by dać każdemu punktowi granicznemu jawną, zapisaną politykę — i sprawić, by walidacja i wykonanie używały tej samej. Poniższa tabela działa jak checklist przeglądu:

Granica Pobłażliwy domyślny stan Zalecany werdykt Reprezentatywna konfiguracja
zduplikowane klucze wygrywa ostatni odrzucać object_pairs_hook w Pythonie; json/v2 w Go odrzuca domyślnie
NaN / Infinity Python akceptuje odrzucać parse_constant w Pythonie rzucający wyjątek
nieznane pola cicho ignorowane decydować wg kontraktu RejectUnknownMembers(true) w json/v2 Go
niepoprawne UTF-8 zależy od implementacji odrzucać jawna walidacja strumienia bajtów w warstwie dekodowania
BOM decyduje ten, kto zdejmuje zdjąć raz na wejściu stały utf-8-sig lub zdjęcie przed parsowaniem
walidacja i wykonanie rozdzielone każdy na siebie jedna implementacja, jedna konfiguracja walidatory używają produkcyjnego parsera

Po stronie Pythona wyłączenie dwóch najbardziej niebezpiecznych domyślnych ustawień kosztuje jedno wywołanie:

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 zduplikowane klucze
)

encoding/json/v2 w Go (pod aliasem jsonv2) czyni całą politykę jawną: RejectUnknownMembers(true) odrzuca nieznane pola, a zduplikowane nazwy wraz z niepoprawnym UTF-8 odrzucane są domyślnie. Strona praktyk GopherForge jest precyzyjna co do kolejności: ogranicz bajty wejściowe, dekoduj według jawnej polityki, zwaliduj domenę i autoryzuj — dopiero wtedy dopuść skutki uboczne; każdą ścieżkę błędu trzeba przećwiczyć na fixturach, nie oceniać po zmienionym komunikacie błędu.

Wprowadź politykę parsowania do kontraktów i korpusów

Polityka potrzebuje ochrony przed dryfem. Wystarczą dwa działania.

Po pierwsze, zapisz „co przyjmujemy, co odrzucamy" w dokumentacji interfejsu obok definicji pól. API7 zaleca stabilny kod błędu, by klienci odróżniali trwały błąd kontraktu od przejściowej awarii infrastruktury — odrzucony zduplikowany klucz nie może wyglądać jak timeout bramy, bo zaprosisz burzę ponowień. Nie wylewaj całego ciała żądania do logów: surowe payloady mogą zawierać poświadczenia, a niektóre niepoprawne sekwencje bajtów są niebezpieczne przy wyświetlaniu.

Po drugie, zbuduj korpus niejednoznaczności. Zamień każdy wiersz powyższej tabeli w fixturę testową: zduplikowane klucze, klucze różniące się wielkością liter, nieznane pola, niepoprawne UTF-8, BOM, druga wartość na końcu, puste wejście. Zapewnij w CI dwie rzeczy: niepoprawne wejścia zawodzą bez produkowania użytecznej wartości częściowej, a zaakceptowane przechodzą rundę kodowania i dekodowania bez zmian. Przy aktualizacji parsera odtwórz produkcyjne próbki w chronionym środowisku w trybie porównania i przeglądaj zmianę w zbiorze akceptacji jako realną zmianę kontraktu, zamiast zakładać, że stare fixture wszystko pokryją.

Te działania uzupełnia Walidacja JSON w CI: pipeline jsonlint, ajv i jq, która opisuje, jak walidacja składni i schematu wpisuje się w pipeline; ten artykuł opisuje to, co przed pierwszym węzłem — sam parser. Ryzyka iniekcji jak prototype pollution i XSS omawia lista ryzyk bezpieczeństwa JSON; problemy łańcucha zaufania na poziomie parsera — zduplikowane klucze i bajty NUL — to dokładnie zerowa warstwa tej listy. Do lokalizowania prostych błędów składni zobacz Granice gramatyki JSON z RFC 8259.

Checklist przed wdrożeniem

  1. Wyrównaj wersje parserów w całym łańcuchu: jq, runtime'y, brama, walidatory offline — poprawki klasy CVE-2026-33948 muszą dotrzeć wszędzie;
  2. Jawnie odrzucaj zduplikowane klucze i NaN: włóż object_pairs_hook i parse_constant do wspólnych wrapperów, nigdy nie wywołuj json.loads nago w kodzie biznesowym;
  3. Decyduj o nieznanych polach per route: konsumenci zgodni w przód mogą je ignorować, endpointy poleceń muszą ustawić RejectUnknownMembers;
  4. Korpus niejednoznaczności w CI: co najmniej 8 fixtur plus porównawczy przebieg stary kontra nowy przed każdą aktualizacją parsera;
  5. Klasyfikowalne błędy: osobne kody dla błędów kontraktu i infrastruktury, ponawiaj tylko te drugie.

Wróćmy do zdania otwierającego: zaliczenie walidacji znaczy „zaakceptowane przez jakiś parser przy jakiejś polityce". Uczyń tę politykę jawną — w kontrakcie, w korpusie, w przypięciu wersji — i „jeden JSON, dwa werdykty" w końcu znika.

FAQ

Czy zduplikowane klucze to naprawdę błąd według specyfikacji JSON?

To nie jest błąd składni. Sekcja 4 RFC 8259 formułuje to tak: nazwy POWINNY być unikalne — zalecenie, nie wymóg — więc główne parsery akceptują duplikaty i domyślnie zostawiają ostatnią wartość. Specyfikacja i tak zaleca unikalność dla interoperacyjności. Podniesienie jej do błędu walidacji to decyzja kontraktowa; wykrycie kosztuje jeden przebieg.

Dlaczego biblioteka json w Pythonie akceptuje NaN, a JavaScript rzuca błąd?

Biblioteka standardowa Pythona celowo akceptuje NaN i Infinity, by umieć odczytać ponownie dane, które historycznie emitowała z utratą. JSON.parse w ECMAScripcie implementuje gramatykę ściśle i rzuca SyntaxError. Przekaż parse_constant w Pythonie — zostaną odrzucone; jedna linijka konfiguracji wyrównuje oba runtime'y.

Których wersji dotyczy CVE-2026-33948 i jak je naprawić?

jq przed 1.8.2 przy czytaniu JSON z plików akceptuje wstawione bajty NUL, przez które etap walidacji i faktyczny parser rozjeżdżają się co do tego samego wejścia, co umożliwia ominięcie walidacji. Poprawka według zalecenia GitHuba to aktualizacja do 1.8.2 albo do builda zawierającego commit 6374ae0. Przypnij wersje w skryptach i CI i przed aktualizacją odpal korpus niejednoznaczności.

Waliduję raz na wejściu i wynik ponownie używam — nadal jestem narażony?

Tak, ale ryzyko koncentruje się w tej jednej bramie wejściowej. Jeśli wejściowy parser, jego konfiguracja i wersja są przypięte, a korpus niejednoznaczności pokrywa zduplikowane klucze, bajty NUL i UTF-8, drugiego arbitra w łańcuchu nie ma. Niebezpieczna topologia to brama na jednej implementacji i serwisy na innej, albo walidacja na jednym parserze i wykonanie na innym — wtedy werdykt oddajesz samej rozbieżności.

Źródła

Pasujące narzędzia

Powiązane artykuły

Walidacja JSON w CI: potok z jsonlint, ajv i jq

Walidacja składni dowodzi, że plik się parsuje; walidacja schematem dowodzi, że pola są zgodne z kontraktem. W CI liczą się jednoznaczne kody wyjścia, lokalizacje błędów i ścieżki naprawy.

Średniozaawansowany~10 min czytaniaZaktualizowano 2026-10-31

Granice gramatyki JSON w świetle RFC 8259

Przekład reguł gramatycznych RFC 8259 na prosty język: które znaki mogą występować bezpośrednio, które trzeba poprzedzić ucieczką i gdzie specyfikacja celowo pozostawia swobodę.

Początkujący~11 min czytaniaZaktualizowano 2026-10-30