Один JSON — два вердикти: відмінності парсерів і межа довіри валідації
Головне: Коли валідатор приймає документ, а сервіс нижче за течією падає, зазвичай два парсери дали різні висновки про той самий текст. Ця стаття перевіряє дублікати ключів, NUL-байти, некоректний UTF-8, NaN і нулі на початку проти реальних середовищ виконання, пояснює, як CVE-2026-33948 перетворює розбіжність на поверхню атаки, і показує, як призначити єдиного арбітра кожній межі.

Успішна валідація доводить рівно одну річ: текст був прийнятий тим парсером за тією політикою. Змініть парсер — і вердикт може перекинутися.
Симптом: інструмент A приймає, інструмент B відхиляє
Сцену знає кожен. Відповідь API, вставлена в онлайн-форматувальник, отримує зелену галочку. Той самий payload сягає сервісу нижче за течією і викидає виняток. Поставте обидва парсери поруч і порівняйте посимвольно: зазвичай ніхто не «помилився» — дані впали точно на точку, де дві реалізації розходяться.
Таких точок небагато, але кожна поширена. Таблиця нижче фіксує реальну поведінку частих входів (перевірено на JSON.parse Node 22, json зі стандартної бібліотеки Python 3.11, jq 1.8 і поширених онлайн-валідаторах):
| Вхід | Node JSON.parse | Python json.loads | jq | Примітки |
|---|---|---|---|---|
{"a":1,"a":2} дублікат ключа |
приймає, лишає останній | приймає, лишає останній | приймає, лишає останній | RFC 8259 каже лише SHOULD; усі чотири пропускають |
{"n":NaN} |
помилка | приймає | помилка | Стандартна бібліотека Python пропускає за замовчуванням — найбільша тиха пастка |
{"n":01} нуль на початку |
помилка | помилка | помилка | Одностайне відхилення, але позиції помилок різняться |
"текст" збережено байтами GBK |
помилка або кракозябри | залежить від оголошення кодування | помилка | RFC вимагає UTF-8; декодування — справа рівня IO |
{"a":1} з BOM попереду |
помилка | приймає (utf-8-sig) | помилка | Хто зрізає BOM — той і вирішує |
| коментарі, одинарні лапки, кома в кінці | помилка | помилка | помилка | Лише парсери JSON5/JSONC їх приймають |
Погляньте на другий рядок: json.loads('{"cpu":NaN}') у Python легальний. Стандартна бібліотека свідомо пропускає NaN/Infinity заради сумісності, і багато конвеєрів порахували ці сміттєві рядки нормальними записами, не помітивши забруднення. Щоб заблокувати, треба явно передати parse_constant — код нижче.
Звідки беруться відмінності: прогалини специфікації
RFC 8259 не розмитий; він свідомо лишає три зони «на розсуд реалізації», і кожна реалізація заповнює їх по-своєму.
Перше — унікальність імен. Розділ 4 каже, що імена SHOULD be unique — рекомендація, а не правило. Отже, дублікат ключа не є синтаксичною помилкою, і парсери всюди обирають «останній перемагає». Бізнес-валідатор бачить лише значення, що вижило; те, яке відправник записав першим, зникає без помилки й без журналу.
Друге — числа. Граматика фіксує лише форму int frac exp; величина залишається реалізації. JavaScript пропускає все через double IEEE 754, тому 9007199254740993 стає ...992. jq зберігає десяткові літерали з 1.8, але будь-яка арифметика повертає double. Той самий документ може мати три різні значення у порівнянні, зберіганні та передачі.
Третє — UTF-8 і невидимі символи. Специфікація вимагає, щоб обмінний JSON був UTF-8, але як відкривається файл, чи зрізається BOM, як обробляються некоректні байти — це рішення рівня IO. Той самий байтовий потік дає різні вердикти залежно від того, чи відкриє Python його як utf-8 чи як utf-8-sig.
Четверте джерело — поблажливі діалекти. JSON5 дозволяє коментарі, одинарні лапки та кому в кінці; JSONC пом'якшує ті самі правила в екосистемі VS Code. Конфіги з поблажливим парсером і API з суворим — найпоширеніший розкол усередині однієї команди.
CVE-2026-33948: розбіжність стає поверхнею атаки
Відмінності парсерів зазвичай лише дратують. Щойно «валідація» та «парсинг» працюють на двох різних реалізаціях, вони стають поверхнею атаки. CVE-2026-33948, розкрита 2026 року, — хрестоматійний приклад: jq до 1.8.2 дозволяв вбудовані NUL-байти (\0) під час читання JSON із файлів, і той самий вхід отримував два вердикти — етап валідації вважав вміст завершеним там, а реальна обробка читала далі. Обхід відбувся. Офіційна рекомендація GitHub підтверджує виправлення: оновлення до 1.8.2.
Узагальнивши: у будь-якому ланцюгу «спершу валідація, потім парсинг», якщо два кроки мають різні реалізації або конфігурації, зловмисник може сконструювати вхід, який валідатор відхиляє, а парсер приймає — і протягнути шкідливий payload. Та сама структура діє на рівні шлюзу — аргумент API7 на користь запису суворого парсингу в контракт API в тому, що семантика парсингу є частиною контракту, а не приватною поведінкою реалізації.
Самоперевірка триває одну команду — переконатися, що кожна ланка на одній версії jq, включно з цим виправленням:
jq --version
# jq-1.7.1 ← вразлива, оновити
# jq-1.8.2 ← виправлено
Дублікати ключів: останнє значення, мовчки проковтнуте
Дублікати ключів заслуговують окремого розділу, бо це єдина межа, яку всі основні парсери приймають, тоді як майже кожен розробник вважає, що вона дає помилку.
import json
text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data) # {'role': 'admin'}
print("guest" in data.values()) # False: перше значення вже зникло
Якщо цей текст живить перевірку підпису або рішення про доступ, зловмисник може додати однойменне поле і перекрити привілей, а ваш код бачить лише фінальне значення. JSON.parse у Node поводиться так само. Щоб виявляти, а не мовчки перезаписувати, Python приймає 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']
Розділ 4 RFC 8259 каже прямо: заради сумісності імена мають бути унікальними. Піднесення цього SHOULD до правила валідації коштує одного проходу й прибирає найчастіше джерело «двох інструментів і двох вердиктів».
Виправлення: кожній межі — єдиного арбітра
Ремонт не в тому, щоб «пересісти на суворіший парсер». Він у тому, щоб дати кожній межі явну, записану політику — і гарантувати, що валідація та виконання користуються однією. Таблиця нижче слугує чеклистом рев'ю:
| Межа | Поблажлива типова поведінка | Рекомендований вердикт | Показова конфігурація |
|---|---|---|---|
| дублікати ключів | останнє перезаписує | відхиляти | Python object_pairs_hook; Go json/v2 відхиляє за замовчуванням |
| NaN / Infinity | Python приймає | відхиляти | Python parse_constant із винятком |
| невідомі поля | мовчки ігноруються | вирішувати за контрактом | Go json/v2 RejectUnknownMembers(true) |
| некоректний UTF-8 | різниться за реалізаціями | відхиляти | явна перевірка байтового потоку на рівні декодування |
| BOM | хто зрізає, той і вирішує | зрізати один раз на вході | фіксований utf-8-sig або попереднє зрізання |
| розділені валідація й виконання | у кожного своє | одна реалізація, одна конфігурація | валідатори повторно використовують бойовий парсер |
У Python вимкнення двох найнебезпечніших усталених значень вміщується в один виклик:
import json
def _reject(value):
raise ValueError(f"non-standard constant: {value}")
data = json.loads(
raw,
parse_constant=_reject, # блокує NaN / Infinity
object_pairs_hook=reject_dup, # блокує дублікати ключів
)
encoding/json/v2 у Go (аліас jsonv2) робить усю політику явною: RejectUnknownMembers(true) відхиляє невідомі поля, а дублікати імен і некоректний UTF-8 відхиляються за замовчуванням. Практична сторінка GopherForge точна в порядку: обмежте вхідні байти, декодуйте за явною політикою, валідуйте домен і авторизуйте — і лише потім дозволяйте побічні ефекти. Кожен шлях відмови мусить бути перевірений фікстурами, а не оцінений за зміною тексту помилки.
Політику парсингу — в контракти та корпуси
Політика потребує захисту від дрейфу. Вистачає двох дій.
По-перше, записати «що приймаємо, що відхиляємо» в документацію інтерфейсу поруч із визначеннями полів. API7 радить стабільний код помилки, щоб клієнт розрізняв постійну помилку контракту і тимчасову відмову інфраструктури — відхилений дублікат ключа не має виглядати як таймаут шлюзу, інакше ви викличете бурю повторів. Не виводьте повне тіло запиту в журнали: сирі payload можуть містити облікові дані, а деякі некоректні байтові послідовності небезпечні навіть для друку.
По-друге, збудуйте корпус неоднозначностей. Кожен рядок таблиці вище стає тест-кейсом: дублікати ключів, ключі, що різняться регістром, невідомі поля, некоректний UTF-8, BOM, зайве значення в кінці, порожній вхід. У CI дві групи перевірок: некоректні входи провалюються, не створивши придатного часткового значення; прийняті входи проходять туди й назад encode/decode без змін. За кожного оновлення парсера прокрутіть зразки виробничої форми в захищеному середовищі в режимі порівняння і розглядайте зміну множини прийняття як справжню зміну контракту.
Ці дії доповнюють Валідація JSON у CI: jsonlint, ajv і jq, де йдеться про вбудовування синтаксичної та схемної валідації в конвеєр; ця стаття — про те, що перед першим вузлом: сам парсер. Ризики ін'єкцій на кшталт забруднення прототипу та XSS покриті у списку ризиків безпеки JSON; проблеми ланцюга довіри на рівні парсинга, як-от дублікати ключів і NUL-байти, — це саме нульовий шар того списку. Пошук чисто синтаксичних помилок — у Межах граматики JSON за RFC 8259.
Чеклист перед випуском
- Вирівняти версії парсерів усього ланцюга: jq, рантайми, шлюз, офлайн-валідатори — по черзі через
--version; виправлення типу CVE-2026-33948 мають дійти всюди; - Явно відхиляти дублікати ключів і NaN:
object_pairs_hookіparse_constant— в спільні обгортки, голі викликиjson.loadsу бізнес-коді заборонити; - Невідомі поля вирішувати на рівні маршруту: сумісні вниз споживачі можуть ігнорувати, командні ендпоінти мусять ставити
RejectUnknownMembers; - Корпус неоднозначностей у CI: щонайменше 8 фікстур, плюс порівняння старе/нове перед кожним оновленням;
- Класифіковані помилки: окремі коди для помилок контракту та інфраструктури, повтори — лише для других.
Повернімося до першої фрази: успішна валідація означає «прийнято якимось парсером за якоюсь політикою». Зробіть цю політику явною — у контракт, у корпус, у пін версій — і «один JSON, два вердикти» нарешті зникне.
FAQ
Чи справді дублікати ключів не є помилкою в специфікації JSON?
Не є синтаксичною помилкою. Розділ 4 RFC 8259 формулює SHOULD be unique — рекомендація, а не вимога — тож основні парсери приймають дублікати й усталено лишають останнє значення. Для сумісності унікальність рекомендується. Підносити це до помилки валідації — рішення контракту; виявлення коштує одного проходу.
Чому бібліотека json у Python приймає NaN, а JavaScript кидає помилку?
Стандартна бібліотека Python свідомо приймає NaN і Infinity, щоб уміти перечитувати власні історичні втратні виводи. JSON.parse ECMAScript суворо реалізує граматику і кидає SyntaxError. Передайте parse_constant у Python — і вони відхилені, а один рядок конфігурації вирівнює поведінку двох середовищ.
Які версії зачіпає CVE-2026-33948 і як її виправити?
jq до 1.8.2, читаючи JSON із файлів, приймає вбудовані NUL-байти, через які етап валідації та реальний парсер дають різні висновки про той самий вхід — так виникає обхід валідації. Виправлення за рекомендацією GitHub — оновлення до 1.8.2 або збірка з комітом 6374ae0. Фіксуйте версії у скриптах і CI та перед оновленням запускайте корпус неоднозначностей.
Я валідую один раз на вході і перевикористовую результат — я все ще під загрозою?
Так, але ризик зосереджується на цьому одному вході. Якщо парсер входу, його конфігурація та версія закріплені, а корпус покриває дублікати, NUL і UTF-8, другого арбітра в ланцюгу немає. Небезпечна топологія — шлюз на одній реалізації та сервіси на іншій, або валідація на одному парсерів і виконання на іншому: це віддає вердикт самій розбіжності.