JSON Toolkit

Un même JSON, deux verdicts : différences de parseurs et frontière de confiance de la validation

L’essentiel : Quand un validateur accepte un document et que le service en aval plante, deux parseurs ont souvent donné des verdicts opposés sur le même texte. Cet article teste clés dupliquées, octets NUL, UTF-8 invalide, NaN et zéros de tête contre de vrais moteurs, explique comment CVE-2026-33948 transforme le désaccord en surface d'attaque et montre comment attribuer un arbitre unique à chaque frontière.

Intermédiaire~6 min de lecturePublié le 2026-11-11Mis à jour le 2026-11-11
Couverture montrant deux outils aux verdicts opposés sur le même document JSON

Passer la validation ne prouve qu'une seule chose : le texte a été accepté par ce parseur, sous cette politique. Changez de parseur et le verdict peut basculer.

Le symptôme : l'outil A accepte, l'outil B rejette

Voici la scène que tout le monde a croisée. Une réponse d'API collée dans un formateur en ligne affiche une coche verte. Le même payload atteint le service en aval et lève une exception. Mettez les deux parseurs côte à côte et comparez caractère par caractère : personne n'a « tort », mais la donnée est tombée pile sur un point où les deux implémentations divergent.

Ces points sont peu nombreux, mais chacun est courant. Le tableau ci-dessous consigne le comportement réel d'entrées fréquentes (testé avec JSON.parse de Node 22, json de la bibliothèque standard Python 3.11, jq 1.8 et des validateurs en ligne répandus) :

Entrée Node JSON.parse Python json.loads jq Remarques
{"a":1,"a":2} clé dupliquée accepte, garde la dernière accepte, garde la dernière accepte, garde la dernière RFC 8259 : simple SHOULD ; tous les quatre laissent passer
{"n":NaN} erreur accepte erreur La bibliothèque Python l'accepte par défaut — le piège silencieux n°1
{"n":01} zéro de tête erreur erreur erreur Rejet uniforme, mais positions d'erreur différentes
"texte" stocké en octets GBK erreur ou caractères illisibles selon la déclaration d'encodage erreur La RFC exige UTF-8 ; le décodage relève de la couche IO
{"a":1} précédé d'un BOM erreur accepte (utf-8-sig) erreur Celui qui retire le BOM décide
commentaires, apostrophes, virgule finale erreur erreur erreur Seuls les parseurs JSON5/JSONC les acceptent

Regardez la deuxième ligne : json.loads('{"cpu":NaN}') est légal en Python. La bibliothèque standard accepte délibérément NaN/Infinity pour des raisons de compatibilité, et beaucoup de pipelines ont compté ces lignes indésirables comme enregistrements normaux sans détecter la contamination. Pour les bloquer, il faut passer explicitement parse_constant — code plus bas.

D'où viennent les différences : les vides de la spécification

RFC 8259 n'est pas flou ; il laisse volontairement trois zones « à l'implémentation », et chaque implémentation les remplit différemment.

Première zone : l'unicité des noms. La section 4 dit que les noms SHOULD be unique — une recommandation, pas une obligation. Une clé dupliquée n'est donc pas une erreur de syntaxe, et les parseurs choisissent partout « le dernier gagne ». Le validateur métier ne voit que la valeur survivante ; celle que l'émetteur a écrite en premier disparaît sans erreur ni journal.

Deuxième zone : les nombres. La grammaire fixe seulement la forme int frac exp ; l'ampleur est laissée à l'implémentation. JavaScript passe tout par des doubles IEEE 754, donc 9007199254740993 devient ...992. jq conserve les littéraux décimaux depuis 1.8, mais tout calcul retombe en double. Le même document peut présenter trois valeurs différentes selon la comparaison, le stockage ou le transport.

Troisième zone : UTF-8 et caractères invisibles. La spécification exige que le JSON échangé soit en UTF-8, mais l'ouverture du fichier, le retrait du BOM et le traitement des octets invalides relèvent de la couche IO. Le même flux d'octets donne des verdicts différents selon que Python ouvre en utf-8 ou en utf-8-sig.

Une quatrième source : les dialectes permissifs. JSON5 autorise commentaires, apostrophes et virgule finale ; JSONC assouplit les mêmes règles dans l'écosystème VS Code. Configurations parsées avec un parseur laxiste et API avec un parseur strict : c'est la divergence la plus courante au sein d'une même équipe.

CVE-2026-33948 : le désaccord devient surface d'attaque

Une différence de parseurs reste d'habitude un problème d'ergonomie. Dès que « validation » et « parsing » tournent sur deux implémentations distinctes, elle devient une surface d'attaque. CVE-2026-33948, divulguée en 2026, est un cas d'école : jq avant 1.8.2 autorisait des octets NUL (\0) imbriqués lors de la lecture de JSON depuis un fichier, si bien que la même entrée recevait deux verdicts — l'étape de validation la considérait comme terminée là, tandis que le traitement réel continuait à lire au-delà. La contournement est complet. L'avis de sécurité GitHub confirme le correctif : passer à 1.8.2.

Généralisons : dans toute chaîne « valider d'abord, parser ensuite », si les deux étapes utilisent des implémentations ou des configurations différentes, un attaquant peut fabriquer une entrée que le validateur rejette et que le parseur accepte, faisant passer une charge malveillante. La même structure vaut au niveau passerelle — l'argument d'API7 pour écrire le parsing strict dans le contrat d'API est que la sémantique de parsing fait partie du contrat, pas du comportement privé d'une implémentation.

L'autocontrôle tient en une commande — vérifier que chaque maillon tourne sur la même version de jq, avec ce correctif :

jq --version
# jq-1.7.1  ← vulnérable, à mettre à jour
# jq-1.8.2  ← corrigé

Les clés dupliquées : la dernière valeur avalée en silence

Les clés dupliquées méritent leur propre section : c'est la seule frontière que tous les parseurs acceptent alors que presque tous les développeurs pensent qu'elle produit une erreur.

import json

text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data)          # {'role': 'admin'}
print("guest" in data.values())  # False : la première valeur a disparu

Si ce texte alimente une vérification de signature ou une décision d'autorisation, un attaquant peut ajouter un champ de même nom pour écraser le privilège, et votre code ne voit que la valeur finale. JSON.parse de Node se comporte pareil. Pour détecter au lieu d'écraser silencieusement, Python accepte 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 section 4 de RFC 8259 le dit franchement : pour l'interopérabilité, les noms devraient être uniques. Élever ce SHOULD en règle de validation coûte un parcours et supprime la source la plus fréquente de « deux outils, deux verdicts ».

Le correctif : un arbitre unique pour chaque frontière

Réparer n'est pas « changer pour un parseur plus strict ». C'est donner à chaque frontière une politique explicite et écrite — et garantir que validation et exécution utilisent la même. Le tableau ci-dessous sert de liste de revue :

Frontière Comportement laxiste par défaut Verdict recommandé Configuration représentative
clés dupliquées la dernière écrase rejeter Python object_pairs_hook ; Go json/v2 rejette par défaut
NaN / Infinity Python accepte rejeter Python parse_constant qui lève
membres inconnus ignorés en silence décider par contrat Go json/v2 RejectUnknownMembers(true)
UTF-8 invalide varie selon l'implémentation rejeter validation explicite du flux d'octets au décodage
BOM celui qui le retire décide le retirer une fois à l'entrée utf-8-sig fixe ou retrait préalable
validation / exécution séparées chacun la sienne une implémentation, une config les validateurs réutilisent le parseur de production

Côté Python, désactiver les deux défauts les plus dangereux tient en un appel :

import json

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

data = json.loads(
    raw,
    parse_constant=_reject,          # bloque NaN / Infinity
    object_pairs_hook=reject_dup,    # bloque les clés dupliquées
)

encoding/json/v2 en Go (aliasé jsonv2) rend toute cette politique explicite : RejectUnknownMembers(true) rejette les membres inconnus, et noms dupliqués ainsi qu'UTF-8 invalide sont rejetés par défaut. La page pratique de GopherForge précise l'ordre : borner les octets d'entrée, décoder sous une politique explicite, valider le domaine et autoriser, et seulement ensuite autoriser les effets de bord — chaque chemin d'échec devant être éprouvé avec des fixtures, pas jugé sur un message d'erreur qui a changé.

Inscrire la politique de parsing dans les contrats et les corpus

La politique doit être protégée de la dérive. Deux actions suffisent.

D'abord, écrire « ce que nous acceptons, ce que nous rejetons » dans la documentation d'interface, à côté des définitions de champs. API7 recommande un code d'erreur stable pour que le client distingue une erreur de contrat permanente d'une panne d'infrastructure temporaire — une clé dupliquée rejetée ne doit pas ressembler à un timeout de passerelle, sinon vous déclenchez une tempête de réessais. N'affichez pas le corps de requête complet dans les journaux : les payloads bruts peuvent contenir des identifiants, et certaines séquences d'octets invalides sont risquées à l'affichage.

Ensuite, construisez un corpus d'ambiguïté. Chaque ligne du tableau ci-dessus devient un cas de test : clés dupliquées, clés différenciées par la casse, membres inconnus, UTF-8 invalide, BOM, valeur surnuméraire finale, entrée vide. En CI, deux assertions : les entrées invalides échouent sans produire de valeur partielle exploitable, et les entrées acceptées survivent à un aller-retour encode/decode inchangées. À chaque mise à niveau de parseur, rejouez des échantillons en forme de production dans un environnement protégé en mode comparaison, et revoyez le changement d'ensemble d'acceptation comme une véritable évolution de contrat.

Ces actions complètent La validation JSON en CI : jsonlint, ajv et jq, qui traite de l'insertion des validations syntaxique et schéma dans le pipeline ; cet article traite ce qui précède le premier nœud — le parseur lui-même. Les risques d'injection comme la pollution de prototype et le XSS sont couverts par la liste des risques de sécurité JSON ; les problèmes de chaîne de confiance au niveau du parsing, comme les clés dupliquées et les octets NUL, en sont exactement la couche zéro. Pour localiser des erreurs de syntaxe, voir Les frontières de la grammaire JSON selon RFC 8259.

Une liste de contrôle avant mise en production

  1. Aligner les versions de parseurs sur toute la chaîne : jq, runtimes, passerelle, validateurs hors ligne — les correctifs de type CVE-2026-33948 doivent arriver partout ;
  2. Rejeter explicitement clés dupliquées et NaN : placer object_pairs_hook et parse_constant dans des enveloppes partagées, jamais d'appel nu à json.loads dans le code métier ;
  3. Décider des membres inconnus par route : les consommateurs rétrocompatibles peuvent les ignorer, les points de commande doivent activer RejectUnknownMembers ;
  4. Corpus d'ambiguïté en CI : au moins 8 fixtures, plus une comparaison ancien/nouveau avant toute mise à niveau ;
  5. Erreurs classifiables : codes distincts pour erreurs de contrat et erreurs d'infrastructure, réessais réservés aux secondes.

Retour à la phrase d'ouverture : passer la validation signifie « accepté par un parseur sous une politique ». Rendez cette politique explicite — dans le contrat, dans le corpus, dans l'épinglage de version — et « un JSON, deux verdicts » disparaît enfin.

FAQ

Les clés dupliquées sont-elles vraiment une erreur dans la spécification JSON ?

Non, pas une erreur de syntaxe. La section 4 de RFC 8259 emploie SHOULD be unique — une recommandation, pas une exigence — donc les parseurs principaux acceptent les doublons et gardent la dernière valeur par défaut. La spécification recommande l'unicité pour l'interopérabilité. Promouvoir cela en erreur de validation est une décision de contrat ; la détection coûte un seul parcours.

Pourquoi la bibliothèque json de Python accepte NaN alors que JavaScript lève une erreur ?

La bibliothèque standard de Python accepte délibérément NaN et Infinity pour pouvoir relire des données qu'elle a elle-même produites avec perte. JSON.parse d'ECMAScript implémente la grammaire strictement et lève une SyntaxError. Passer parse_constant en Python les rejette, et une ligne de configuration aligne les deux moteurs.

Quelles versions CVE-2026-33948 touche-t-elle, et comment corriger ?

jq avant 1.8.2, en lisant le JSON depuis un fichier, accepte des octets NUL imbriqués qui font diverger l'étape de validation et le parseur réel sur la même entrée, permettant une contournement de validation. Le correctif de l'avis GitHub est de passer à 1.8.2 ou à une version contenant le commit 6374ae0. Épinglez les versions dans les scripts et la CI, et exécutez le corpus d'ambiguïté avant toute mise à niveau.

Je valide une seule fois à l'entrée et je réutilise le résultat — suis-je encore exposé ?

Oui, mais le risque se concentre sur ce point d'entrée unique. Si le parseur d'entrée, sa configuration et sa version sont épinglés, et que le corpus couvre clés dupliquées, NUL et UTF-8, il n'y a pas de second arbitre dans la chaîne. La topologie dangereuse est une passerelle sur une implémentation et des services sur une autre, ou une validation sur un parseur et une exécution sur un autre — cela remet le verdict au désaccord lui-même.