JSON Toolkit

Uno stesso JSON, due verdeti: differenze tra parser e confine di fiducia della validazione

In sintesi: Quando un validatore accetta un documento e il servizio a valle va in errore, di solito due parser hanno discordato sullo stesso testo. Questo articolo confronta chiavi duplicate, byte NUL, UTF-8 non valido, NaN e zeri iniziali su runtime reali, spiega come CVE-2026-33948 ha trasformato la discrepanza in superficie di attacco e mostra come assegnare un unico arbitro a ogni confine.

Advanced~6 min di letturaPubblicato il 2026-11-11Aggiornato il 2026-11-11
Copertina con due strumenti che emettono verdeti opposti sullo stesso documento JSON

Superare la validazione dimostra esattamente una cosa: il testo è stato accettato da quel parser, sotto quella politica. Cambia parser e il verdetto può ribaltarsi.

Il sintomo: lo strumento A approva, lo strumento B rifiuta

È la scena che tutti abbiamo incontrato. Una risposta di un'API incollata in un formattatore online riceve la spunta verde. Lo stesso payload arriva a un servizio a valle e genera un'eccezione. Quando metti i due parser fianco a fianco e confronti carattere per carattere, di solito nessuno dei due è "sbagliato": i dati sono caduti esattamente su un punto in cui le due implementazioni discordano.

Questi punti non sono tanti, ma ognuno è comune. La tabella seguente registra il comportamento reale su input ad alta frequenza (testato contro Node 22 JSON.parse, Python 3.11 stdlib json, jq 1.8 e validatori online diffusi):

Input Node JSON.parse Python json.loads jq Note
{"a":1,"a":2} chiave duplicata accetta, tiene l'ultimo accetta, tiene l'ultimo accetta, tiene l'ultimo RFC 8259 dice solo SHOULD; tutti e quattro lo lasciano passare
{"n":NaN} errore accetta errore La stdlib di Python lo accetta di default — la trappola silenziosa più grande
{"n":01} zero iniziale errore errore errore Rifiutato ovunque, ma le posizioni degli errori differiscono
"中文" salvata come byte GBK errore o mojibake dipende dalla codifica errore RFC richiede UTF-8, ma decodificare spetta al layer IO
{"a":1} con BOM errore accetta (utf-8-sig) errore Decide chi rimuove il BOM
commenti, apostrofi, virgole finali errore errore errore Solo i parser JSON5/JSONC li accettano

Guarda la seconda riga: json.loads('{"cpu":NaN}') è legale in Python. La libreria standard accetta deliberatamente NaN/Infinity per compatibilità con il passato, e molti pipeline hanno contato queste righe di spazzatura come record normali senza accorgersi della contaminazione. Bloccarle richiede un argomento parse_constant esplicito — codice più avanti.

Da dove nascono le differenze: lacune della specifica e scelte d'implementazione

L'RFC 8259 non è vago; lascia deliberatamente tre aree "all'implementazione", e ogni implementazione le riempie in modo diverso.

Prima, l'unicità dei nomi degli oggetti. La sezione 4 dice che i nomi DOVREBBERO essere unici — una raccomandazione, non una regola. Quindi una chiave duplicata non è un errore di sintassi, e i parser ovunque scelgono "vince l'ultimo". Un validatore di business vede allora solo il valore superstite; il valore che il mittente ha inviato per primo è svanito senza errore né riga di log.

Seconda, i numeri. La grammatica fissa solo la forma int frac exp; la grandezza è lasciata all'implementazione. JavaScript forza tutto attraverso double IEEE 754, quindi 9007199254740993 diventa ...992. jq conserva fedelmente i letterali decimali dalla 1.8, ma ogni aritmetica ricade nei double. Lo stesso documento può presentare tre valori diversi tra confronto, archiviazione e trasporto.

Terza, UTF-8 e caratteri invisibili. La specifica richiede che il JSON scambiato sia UTF-8, ma come si apre un file, se il BOM viene rimosso e come si trattano i byte non validi sono decisioni del layer IO. Lo stesso flusso di byte dà verdeti diversi a seconda che Python lo apra come utf-8 o utf-8-sig.

Una quarta fonte sono i dialetti permissivi. JSON5 ammette commenti, apostrofi e virgole finali; JSONC rilassa le stesse regole nell'ecosistema VS Code. Configurazioni analizzate con un parser tollerante e API analizzate con uno rigoroso sono la divergenza più comune dentro un singolo team.

CVE-2026-33948: quando la discrepanza diventa superficie d'attacco

Le differenze tra parser sono di solito un fastidio per l'esperienza d'uso. Appena "validare" e "analizzare" girano su due implementazioni diverse, diventano una superficie d'attacco. CVE-2026-33948, divulgato nel 2026, è un caso da manuale: jq nelle versioni precedenti alla 1.8.2 accettava byte NUL incorporati (\0) leggendo JSON da file, così lo stesso input produceva due verdeti — la fase di validazione trattava il contenuto come terminato lì, mentre la fase reale di elaborazione continuava a leggere oltre. Il bypass è completo. L'advisory di sicurezza di GitHub conferma la correzione: aggiornare alla 1.8.2.

Ricava la lezione: in qualsiasi catena "prima valida, poi analizza", se i due passi usano implementazioni o configurazioni diverse, un attaccante può costruire un input che il validatore rifiuta e il parser accetta, facendo passare un payload oltre il controllo. La stessa struttura si ripete al gateway — l'argomento di API7 per scrivere il parsing strict nel contratto di API è che la semantica di parsing fa parte del contratto, non un comportamento privato di un'implementazione. Quando il gateway rifiuta una richiesta sotto un insieme di regole e il servizio backend accetta lo stesso corpo sotto un altro parser, il contratto si è già rotto.

Un autocontrollo sta in un comando — verifica che ogni fase usi la stessa versione di jq, inclusa questa correzione:

jq --version
# jq-1.7.1  ← vulnerabile, aggiornare
# jq-1.8.2  ← corretto

Chiavi duplicate: l'ultimo valore ingoia il primo in silenzio

Le chiavi duplicate meritano una sezione propria perché sono l'unico confine che tutti i parser mainstream accettano mentre quasi ogni sviluppatore dà per scontato che sia un errore.

import json

text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data)          # {'role': 'admin'}
print("guest" in data.values())  # False: il primo valore è sparito

Se quel testo alimenta un controllo di firma o una decisione di permessi, un attaccante può aggiungere un campo con lo stesso nome per sovrascrivere il privilegio, e il tuo codice di validazione vede solo il valore finale. Il JSON.parse di Node si comporta allo stesso modo. Per rilevare invece di sovrascrivere in silenzio, Python accetta un 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']

La sezione 4 dell'RFC 8259 lo dice senza giri di parole: per l'interoperabilità, i nomi DOVREBBERO essere unici. Promuovere quel SHOULD a regola di validazione costa un solo passaggio ed elimina la fonte più comune di "due strumenti, due verdeti".

La soluzione: un arbitro per ogni confine

La riparazione non è "passare a un parser più rigoroso". È dare a ogni punto di confine una politica esplicita e scritta — e far sì che validazione ed esecuzione usino la stessa. La tabella seguente funziona come checklist di revisione:

Confine Default tollerante Verdetto consigliato Configurazione rappresentativa
chiavi duplicate vince l'ultimo rifiutare object_pairs_hook in Python; json/v2 di Go rifiuta di default
NaN / Infinity Python accetta rifiutare parse_constant in Python che solleva errore
membri sconosciuti ignorati in silenzio decidere per contratto RejectUnknownMembers(true) in json/v2 di Go
UTF-8 non valido varia per implementazione rifiutare validazione esplicita del flusso di byte nel layer di decodifica
BOM decide chi lo rimuove rimuovere una volta all'ingresso utf-8-sig fisso o rimozione prima del parsing
validazione ed esecuzione separate ciascuno il suo un'implementazione, una configurazione i validatori riutilizzano il parser di produzione

Lato Python, disattivare i due default più pericolosi costa una chiamata:

import json

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

data = json.loads(
    raw,
    parse_constant=_reject,          # blocca NaN / Infinity
    object_pairs_hook=reject_dup,    # blocca le chiavi duplicate
)

encoding/json/v2 in Go (con alias jsonv2) rende esplicita l'intera politica: RejectUnknownMembers(true) rifiuta i campi sconosciuti, e i nomi duplicati insieme all'UTF-8 non valido vengono rifiutati di default. La pagina di pratiche di GopherForge è precisa sull'ordine: delimita i byte di input, decodifica sotto una politica esplicita, valida il dominio e autorizza, e solo allora consenti effetti collaterali — e ogni percorso di errore va esercitato con fixture, non giudicato da una stringa d'errore cambiata.

Porta la politica di parsing nei contratti e nei corpus

La politica ha bisogno di protezione dalla deriva. Bastano due azioni.

Prima, scrivi "cosa accettiamo, cosa rifiutiamo" nella documentazione di interfaccia accanto alle definizioni dei campi. API7 raccomanda un codice di errore stabile perché i client distinguano un errore permanente di contratto da un guasto transitorio d'infrastruttura — una chiave duplicata rifiutata non deve sembrare un timeout del gateway, o invitì una tempesta di retry. Non riversare il corpo completo della richiesta nei log: i payload grezzi possono contenere credenziali, e alcune sequenze di byte non valide non sono sicure da mostrare.

Seconda, costruisci un corpus di ambiguità. Trasforma ogni riga della tabella precedente in una fixture di test: chiavi duplicate, chiavi con maiuscole diverse, membri sconosciuti, UTF-8 non valido, BOM, un secondo valore finale, input vuoto. Assicura due cose in CI: gli input non validi falliscono senza produrre un valore parziale utilizzabile, e quelli accettati sopravvivono immutati a un viaggio di andata e ritorno di codifica e decodifica. Quando aggiorni un parser, riproduci campioni di forma produttiva in ambiente protetto in modalità confronto, e rivedi il cambiamento nel set di accettazione come una vera modifica di contratto invece di dare per scontato che le vecchie fixture coprano tutto.

Queste azioni completano Validazione JSON in CI: pipeline con jsonlint, ajv e jq, che copre come la validazione sintattica e di schema si inseriscono nel pipeline; questo articolo copre ciò che viene prima del primo nodo — il parser stesso. I rischi d'iniezione come la prototype pollution e l'XSS sono trattati in la checklist dei rischi di sicurezza JSON; i problemi di catena di fiducia a livello di parser, come chiavi duplicate e byte NUL, sono esattamente lo strato zero di quella lista. Per localizzare semplici errori di sintassi, vedi I confini della grammatica JSON dall'RFC 8259.

Checklist prima del rilascio

  1. Allinea le versioni dei parser su tutta la catena: jq, runtime, gateway, validatori offline — le correzioni di tipo CVE-2026-33948 devono arrivare ovunque;
  2. Rifiuta esplicitamente chiavi duplicate e NaN: metti object_pairs_hook e parse_constant in wrapper condivisi, mai chiamare json.loads nudo nel codice di business;
  3. Decidi i membri sconosciuti per rotta: i consumer forward-compatible possono ignorarli, gli endpoint di comando devono impostare RejectUnknownMembers;
  4. Corpus di ambiguità in CI: almeno 8 fixture, più una esecuzione comparativa vecchio-contro-nuovo prima di ogni aggiornamento del parser;
  5. Errori classificabili: codici distinti per errori di contratto e d'infrastruttura, riprova solo i secondi.

Torniamo alla frase d'apertura: superare la validazione significa "accettato da qualche parser sotto qualche politica". Rendi quella politica esplicita — nel contratto, nel corpus, nel pinning delle versioni — e "uno stesso JSON, due verdeti" sparisce finalmente.

FAQ

Le chiavi duplicate sono davvero un errore nella specifica JSON?

Non è un errore di sintassi. La sezione 4 dell'RFC 8259 lo formula come nomi DOVREBBERO essere unici — una raccomandazione, non un requisito — quindi i parser principali accettano i duplicati e tengono l'ultimo valore di default. La specifica raccomanda comunque l'unicità per l'interoperabilità. Promuoverlo a errore di validazione è una decisione di contratto; rilevarlo costa un solo passaggio.

Perché la libreria json di Python accetta NaN mentre JavaScript lancia un errore?

La libreria standard di Python accetta deliberatamente NaN e Infinity per poter rileggere dati che storicamente ha emesso con perdita. Il JSON.parse di ECMAScript implementa la grammatica in modo rigoroso e lancia SyntaxError. Passando parse_constant in Python li rifiuta, e una riga di configurazione allinea i due runtime.

Quali versioni sono interessate da CVE-2026-33948 e come si corregge?

jq prima della 1.8.2, leggendo JSON da file, accetta byte NUL incorporati che fanno discordare la fase di validazione e il parser reale sullo stesso input, abilitando un bypass di validazione. La correzione dell'advisory di GitHub è aggiornare alla 1.8.2 o a una build contenente il commit 6374ae0. Fissa le versioni in script e CI, ed esegui il corpus di ambiguità prima di aggiornare.

Valido una volta all'ingresso e riuso il risultato — sono comunque esposto?

Sì, ma il rischio si concentra su quel singolo punto d'ingresso. Se il parser d'ingresso, la sua configurazione e la sua versione sono fissati, e il corpus di ambiguità copre chiavi duplicate, byte NUL e UTF-8, non c'è un secondo arbitro dentro la catena. La topologia pericolosa è un gateway su un'implementazione e servizi su un'altra, o validazione su un parser ed esecuzione su un altro — questo consegna il verdetto alla discrepanza stessa.