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

Прохождение валидации доказывает ровно одну вещь: текст был принят этим парсером при этой политике. Смените парсер — и вердикт может измениться.
Симптом: инструмент A пропускает, инструмент B отклоняет
Каждый встречал эту сцену. Ответ API вставляют в онлайн-форматировщик — зелёная галочка. Тот же payload доходит до следующего сервиса — исключение. Когда ставишь оба парсера рядом и сравниваешь посимвольно, обычно ни одна сторона не «ошиблась»: данные попали ровно в точку, где две реализации расходятся.
Таких точек немного, но каждая из них частая. Таблица ниже фиксирует реальное поведение на высокочастотных входах (проверено на Node 22 JSON.parse, стандартном 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 быть уникальными — рекомендация, а не правило. Поэтому дублирующийся ключ не является синтаксической ошибкой, и парсеры повсюду выбирают «побеждает последний». Бизнес-валидатор видит лишь выжившее значение; значение, которое отправитель передал первым, исчезло без ошибки и без строки лога.
Второе — числа. Грамматика фиксирует только форму int frac exp; величина отдаётся реализации. JavaScript прогоняет всё через числа IEEE 754 double, поэтому 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 быть уникальными. Превратить этот SHOULD в правило валидации стоит одного прохода и устраняет самый частый источник «двух инструментов — двух вердиктов».
Решение: один арбитр на каждую границу
Починка не в том, чтобы «перейти на более строгий парсер». Она в том, чтобы дать каждой граничной точке явную, записанную политику — и сделать так, чтобы валидация и исполнение использовали одну и ту же. Таблица ниже работает как чек-лист ревью:
| Граница | Мягкое поведение по умолчанию | Рекомендуемый вердикт | Типовая конфигурация |
|---|---|---|---|
| дублирующиеся ключи | побеждает последний | отклонять | object_pairs_hook в Python; json/v2 в Go отклоняет по умолчанию |
| NaN / Infinity | Python принимает | отклонять | parse_constant в Python с исключением |
| неизвестные поля | молча игнорируются | решать по контракту | RejectUnknownMembers(true) в json/v2 Go |
| некорректный 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 две вещи: неверные входы падают, не породив пригодного частичного значения, а принятые проходят кодирование и декодирование без изменений. При обновлении парсера воспроизводите продакшн-образцы в защищённой среде в режиме сравнения и рассматривайте изменение в принимающем наборе как реальное изменение контракта, а не как «старые фикстуры всё покрывают».
Эти действия дополняют Валидация JSON в CI: пайплайны jsonlint, ajv и jq, где описано, как синтаксическая и схемная валидация встраиваются в пайплайн; эта статья — о том, что идёт до первого узла: о самом парсере. Инъекционные риски вроде pollution прототипов и XSS разобраны в чек-листе рисков безопасности JSON; проблемы цепочки доверия на уровне парсера — дублирующиеся ключи и NUL-байты — это ровно нулевой слой того списка. Для поиска простых синтаксических ошибок см. Границы грамматики JSON из RFC 8259.
Чек-лист перед запуском
- Выровняйте версии парсеров по всей цепочке: jq, рантаймы, шлюз, офлайн-валидаторы — исправления класса CVE-2026-33948 должны доехать везде;
- Явно отклоняйте дублирующиеся ключи и NaN: вынесите
object_pairs_hookиparse_constantв общие обёртки, никогда не вызывайтеjson.loadsв чистом виде в бизнес-коде; - Решайте судьбу неизвестных полей по маршрутам: потребители с прямой совместимостью могут игнорировать их, командные эндпоинты обязаны включить
RejectUnknownMembers; - Корпус неоднозначностей в CI: минимум 8 фикстур плюс сравнительный прогон старого против нового перед любым обновлением парсера;
- Классифицируемые ошибки: разные коды для контрактных и инфраструктурных сбоев, повторяйте только вторые.
Вернёмся к первой фразе: прохождение валидации означает «принято неким парсером при некой политике». Сделайте эту политику явной — в контракте, в корпусе, в закреплении версий — и «один JSON — два вердикта» наконец исчезает.
FAQ
Дублирующиеся ключи — это вообще ошибка по спецификации JSON?
Нет, это не синтаксическая ошибка. Раздел 4 RFC 8259 формулирует это как «имена SHOULD быть уникальными» — рекомендация, а не требование, поэтому основные парсеры принимают дубликаты и по умолчанию оставляют последнее значение. Спецификация всё же рекомендует уникальность ради интероперабельности. Превращать её в ошибку валидации — решение контракта; обнаружение стоит одного прохода.
Почему библиотека 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, второго арбитра внутри цепочки нет. Опасная топология — шлюз на одной реализации и сервисы на другой, или валидация на одном парсере, а исполнение на другом: тогда вердикт вручается самому расхождению.