JSON Toolkit

Um JSON, dois vereditos: diferenças entre parsers e a fronteira de confiança da validação

Resumo: Quando um validador aceita o documento e o serviço a jusante quebra, geralmente dois parsers deram vereditos diferentes sobre o mesmo texto. Este artigo testa chaves duplicadas, bytes NUL, UTF-8 inválido, NaN e zeros à esquerda contra runtimes reais, explica como CVE-2026-33948 transforma a divergência em superfície de ataque e mostra como atribuir um árbitro único a cada fronteira.

Intermediário~6 min de leituraPublicado em 2026-11-11Atualizado em 2026-11-11
Capa mostrando duas ferramentas com vereditos opostos sobre o mesmo documento JSON

Passar na validação prova exatamente uma coisa: o texto foi aceito por aquele parser, sob aquela política. Troque o parser e o veredito pode inverter.

O sintoma: a ferramenta A aprova, a ferramenta B rejeita

Todo mundo já viu a cena. Uma resposta de API colada num formatador online recebe um visto verde. O mesmo payload chega ao serviço a jusante e lança uma exceção. Colocando os dois parsers lado a lado e comparando caractere por caractere, geralmente ninguém "errou" — os dados caíram exatamente num ponto onde as duas implementações divergem.

Esses pontos não são muitos, mas cada um é comum. A tabela abaixo registra o comportamento real de entradas frequentes (testado com JSON.parse do Node 22, json da biblioteca padrão do Python 3.11, jq 1.8 e validadores online conhecidos):

Entrada Node JSON.parse Python json.loads jq Observações
{"a":1,"a":2} chave duplicada aceita, mantém a última aceita, mantém a última aceita, mantém a última RFC 8259 diz apenas SHOULD; todos os quatro deixam passar
{"n":NaN} erro aceita erro A biblioteca padrão do Python permite por padrão — a maior armadilha silenciosa
{"n":01} zero à esquerda erro erro erro Rejeição uniforme, mas posições do erro diferem
"texto" salvo em bytes GBK erro ou caracteres quebrados depende da declaração de codificação erro A RFC exige UTF-8; a decodificação é da camada de IO
{"a":1} precedido de BOM erro aceita (utf-8-sig) erro Quem remove o BOM decide
comentários, aspas simples, vírgula final erro erro erro Só parsers JSON5/JSONC aceitam

Olhe a segunda linha: json.loads('{"cpu":NaN}') é legal em Python. A biblioteca padrão aceita NaN/Infinity deliberadamente por compatibilidade, e muitos pipelines contaram essas linhas de lixo como registros normais sem perceber a contaminação. Para bloquear, é preciso passar parse_constant explicitamente — código abaixo.

De onde vêm as diferenças: lacunas da especificação

RFC 8259 não é vago; ele deixa deliberadamente três áreas "a cargo da implementação", e cada implementação as preenche de um jeito.

Primeira: a unicidade dos nomes. A seção 4 diz que os nomes SHOULD be unique — recomendação, não obrigação. Uma chave duplicada não é erro de sintaxe, e os parsers escolhem "o último vence". O validador de negócio vê apenas o valor sobrevivente; o valor que o emissor escreveu primeiro desaparece sem erro nem log.

Segunda: números. A gramática fixa apenas a forma int frac exp; a magnitude fica a cargo da implementação. JavaScript força tudo por doubles IEEE 754, então 9007199254740993 vira ...992. O jq preserva literais decimais desde 1.8, mas qualquer aritmética volta ao double. O mesmo documento pode apresentar três valores diferentes na comparação, no armazenamento e no transporte.

Terceira: UTF-8 e caracteres invisíveis. A especificação exige que JSON trocado seja UTF-8, mas como o arquivo é aberto, se o BOM é removido e como bytes inválidos são tratados são decisões da camada de IO. O mesmo fluxo de bytes dá vereditos diferentes conforme o Python abra com utf-8 ou utf-8-sig.

Uma quarta fonte são os dialetos permissivos. JSON5 permite comentários, aspas simples e vírgula final; o JSONC relaxa as mesmas regras no ecossistema VS Code. Configurações com parser leniente e APIs com parser estrito é a divergência mais comum dentro de um mesmo time.

CVE-2026-33948: a divergência vira superfície de ataque

Diferenças de parser costumam ser um incômodo de experiência. No momento em que "validação" e "parsing" rodam em duas implementações diferentes, viram superfície de ataque. CVE-2026-33948, divulgada em 2026, é um caso de manual: o jq antes da 1.8.2 permitia bytes NUL (\0) embutidos ao ler JSON de arquivos, e a mesma entrada recebia dois vereditos — a etapa de validação considerava o conteúdo encerrado ali, enquanto o processamento real continuava lendo além. O bypass se completa. O aviso de segurança oficial do GitHub confirma a correção: atualizar para 1.8.2.

Generalizando: em qualquer cadeia "validar primeiro, parsear depois", se os dois passos usam implementações ou configurações diferentes, um atacante pode construir uma entrada que o validador rejeita e o parser aceita, esgueirando um payload malicioso. A mesma estrutura vale na camada de gateway — o argumento da API7 para escrever parsing estrito no contrato da API é que a semântica de parsing faz parte do contrato, não é comportamento privado de uma implementação.

O autoexame cabe em um comando — confirmar que cada elo roda a mesma versão do jq, incluindo essa correção:

jq --version
# jq-1.7.1  ← vulnerável, atualizar
# jq-1.8.2  ← corrigido

Chaves duplicadas: o último valor engolido em silêncio

Chaves duplicadas merecem seção própria porque são a única fronteira que todo parser principal aceita enquanto quase todo desenvolvedor assume que dá erro.

import json

text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data)          # {'role': 'admin'}
print("guest" in data.values())  # False: o primeiro valor já se foi

Se esse texto alimenta uma checagem de assinatura ou uma decisão de permissão, um atacante pode acrescentar um campo homônimo para sobrepor o privilégio, e seu código só vê o valor final. O JSON.parse do Node se comporta igual. Para detectar em vez de sobrescrever em silêncio, o Python aceita um 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']

A seção 4 da RFC 8259 diz sem rodeios: para interoperabilidade, os nomes deveriam ser únicos. Promover esse SHOULD a regra de validação custa uma passagem e elimina a fonte mais comum de "duas ferramentas, dois vereditos".

O conserto: um árbitro único para cada fronteira

Reparar não é "trocar por um parser mais estrito". É dar a cada fronteira uma política explícita e escrita — e garantir que validação e execução usem a mesma. A tabela abaixo serve como checklist de revisão:

Fronteira Comportamento permissivo padrão Veredito recomendado Configuração representativa
chaves duplicadas a última sobrepõe rejeitar Python object_pairs_hook; Go json/v2 rejeita por padrão
NaN / Infinity Python aceita rejeitar Python parse_constant lançando exceção
membros desconhecidos ignorados em silêncio decidir por contrato Go json/v2 RejectUnknownMembers(true)
UTF-8 inválido varia por implementação rejeitar validação explícita do fluxo de bytes na decodificação
BOM quem remove decide remover uma vez na entrada utf-8-sig fixo ou remoção prévia
validação e execução separadas cada uma a sua uma implementação, uma configuração validadores reutilizam o parser de produção

No lado Python, desligar os dois padrões mais perigosos cabe numa chamada:

import json

def _reject(value):
    raise ValueError(f"non-standard constant: {value}")

data = json.loads(
    raw,
    parse_constant=_reject,          # bloqueia NaN / Infinity
    object_pairs_hook=reject_dup,    # bloqueia chaves duplicadas
)

O encoding/json/v2 do Go (apelidado jsonv2) torna toda essa política explícita: RejectUnknownMembers(true) rejeita campos desconhecidos, e nomes duplicados e UTF-8 inválido são rejeitados por padrão. A página prática do GopherForge é precisa na ordem: limite os bytes de entrada, decodifique sob uma política explícita, valide o domínio e autorize, e só então permita efeitos colaterais — cada caminho de falha testado com fixtures, não julgado por uma mensagem de erro que mudou.

Levar a política de parsing aos contratos e aos corpora

A política precisa de proteção contra deriva. Duas ações bastam.

Primeira: escrever "o que aceitamos, o que rejeitamos" na documentação da interface, junto das definições de campos. A API7 recomenda um código de erro estável para que o cliente distinga um erro permanente de contrato de uma falha temporária de infraestrutura — uma chave duplicada rejeitada não pode parecer um timeout de gateway, senão você convoca uma tempestade de retentativas. Não ecoe o corpo completo da requisição nos logs: payloads brutos podem conter credenciais, e algumas sequências inválidas de bytes são arriscadas até para imprimir.

Segunda: construir um corpus de ambiguidade. Cada linha da tabela acima vira um caso de teste: chaves duplicadas, chaves diferenciadas por caixa, membros desconhecidos, UTF-8 inválido, BOM, um valor extra no fim, entrada vazia. Na CI, duas asserções: entradas inválidas falham sem produzir valor parcial utilizável, e entradas aceitas sobrevivem a uma ida e volta encode/decode inalteradas. Ao atualizar o parser, repasse amostras em forma de produção num ambiente protegido em modo de comparação e revise a mudança do conjunto de aceitação como uma verdadeira mudança de contrato.

Essas ações complementam Validação JSON na CI: jsonlint, ajv e jq, que cobre como as validações sintática e de esquema entram no pipeline; este artigo cobre o que vem antes do primeiro nó — o parser em si. Riscos de injeção como poluição de protótipo e XSS estão cobertos na lista de riscos de segurança do JSON; problemas de cadeia de confiança no nível do parsing, como chaves duplicadas e bytes NUL, são exatamente a camada zero dessa lista. Para localizar erros de sintaxe, veja As fronteiras da gramática JSON segundo a RFC 8259.

Uma checklist antes de ir para produção

  1. Alinhar versões de parser em toda a cadeia: jq, runtimes, gateway, validadores offline, um por um com --version; correções do tipo CVE-2026-33948 precisam chegar a todos;
  2. Rejeitar explicitamente chaves duplicadas e NaN: coloque object_pairs_hook e parse_constant em wrappers compartilhados, proíba chamadas nuas de json.loads no código de negócio;
  3. Decidir membros desconhecidos por rota: consumidores retrocompatíveis podem ignorar, endpoints de comando precisam de RejectUnknownMembers;
  4. Corpus de ambiguidade na CI: pelo menos 8 fixtures, mais comparação antigo/novo antes de qualquer atualização;
  5. Erros classificáveis: códigos distintos para erros de contrato e de infraestrutura, retentativa só para os últimos.

De volta à frase de abertura: passar na validação significa "aceito por algum parser sob alguma política". Torne essa política explícita — no contrato, no corpus, no pinning de versão — e "um JSON, dois vereditos" desaparece de vez.

FAQ

Chaves duplicadas realmente não são um erro na especificação JSON?

Não são erro de sintaxe. A seção 4 da RFC 8259 usa SHOULD be unique — recomendação, não exigência —, então os parsers principais aceitam duplicatas e mantêm o último valor por padrão. A especificação recomenda unicidade para interoperabilidade. Promover isso a erro de validação é decisão de contrato; a detecção custa uma única passagem.

Por que a biblioteca json do Python aceita NaN enquanto o JavaScript lança erro?

A biblioteca padrão do Python aceita NaN e Infinity deliberadamente para conseguir reler dados que ela mesma emitiu com perdas no passado. O JSON.parse do ECMAScript implementa a gramática estritamente e lança SyntaxError. Passar parse_constant no Python os rejeita, e uma linha de configuração alinha os dois runtimes.

Quais versões a CVE-2026-33948 afeta, e como corrigir?

O jq antes da 1.8.2, ao ler JSON de arquivos, aceita bytes NUL embutidos que fazem a etapa de validação e o parser real discordarem sobre a mesma entrada, permitindo bypass de validação. A correção do aviso do GitHub é atualizar para 1.8.2 ou para um build contendo o commit 6374ae0. Fixe versões em scripts e CI, e rode o corpus de ambiguidade antes de atualizar.

Valido uma vez na entrada e reutilizo o resultado — ainda estou exposto?

Sim, mas o risco se concentra nesse ponto de entrada único. Se o parser de entrada, sua configuração e sua versão estiverem fixados, e o corpus cobrir chaves duplicadas, NUL e UTF-8, não existe segundo árbitro na cadeia. A topologia perigosa é um gateway numa implementação e serviços em outra, ou validação num parser e execução em outro — isso entrega o veredito à própria divergência.

Referências

Ferramentas relacionadas

Artigos relacionados

Validação JSON no CI: um pipeline com jsonlint, ajv e jq

A validação de sintaxe prova que um arquivo é analisável; a validação de schema prova que os campos seguem o contrato. No CI, o que importa são códigos de saída inequívocos, localização de erros e caminhos de correção.

Intermediário~10 min de leituraAtualizado em 2026-10-31

Lendo os limites da gramática JSON na RFC 8259

Traduzindo as produções gramaticais da RFC 8259 para linguagem simples: quais caracteres podem aparecer diretamente, quais precisam ser escapados e onde a especificação deixa margem de propósito.

Iniciante~11 min de leituraAtualizado em 2026-10-30