JSON, XML & Yaml Hacking & Issues

Reading time: 5 minutes

Go JSON Decoder

Les problèmes suivants ont été détectés dans le Go JSON bien qu'ils puissent également être présents dans d'autres langages. Ces problèmes ont été publiés dans cet article de blog.

Les parseurs JSON, XML et YAML de Go ont une longue liste d'incohérences et de valeurs par défaut non sécurisées qui peuvent être exploitées pour contourner l'authentification, escalader les privilèges ou exfiltrer des données sensibles.

(Un)Marshaling Unexpected Data

L'objectif est d'exploiter des structures qui permettent à un attaquant de lire/écrire des champs sensibles (par exemple, IsAdmin, Password).

• Exemple de structure :

type User struct {
Username string `json:"username,omitempty"`
Password string `json:"password,omitempty"`
IsAdmin  bool   `json:"-"`
}

• Vulnérabilités courantes

1. Tag manquant (pas de tag = le champ est toujours analysé par défaut) :

type User struct {
Username string
}

Charge utile :

{"Username": "admin"}

2. Utilisation incorrecte de -:

type User struct {
IsAdmin bool `json:"-,omitempty"` // ❌ wrong
}

Charge utile :

{"-": true}

✔️ Méthode appropriée pour bloquer un champ de (dé)sérialisation :

type User struct {
IsAdmin bool `json:"-"`
}

Différences de Parser

L'objectif est de contourner l'autorisation en exploitant la façon dont différents parsers interprètent la même charge utile de manière différente, comme dans :

• CVE-2017-12635 : contournement d'Apache CouchDB via des clés dupliquées
• 2022 : RCE 0-click de Zoom via une incohérence du parser XML
• Contournement SAML de GitLab 2025 via des particularités XML

1. Champs Dupliqués : Le encoding/json de Go prend le dernier champ.

json.Unmarshal([]byte(`{"action":"UserAction", "action":"AdminAction"}`), &req)
fmt.Println(req.Action) // AdminAction

D'autres analyseurs (par exemple, Jackson de Java) peuvent prendre le premier.

2. Insensibilité à la casse : Go est insensible à la casse :

json.Unmarshal([]byte(`{"AcTiOn":"AdminAction"}`), &req)
// matches `Action` field

Même les astuces Unicode fonctionnent :

json.Unmarshal([]byte(`{"aKtionſ": "bypass"}`), &req)

3. Mismatch entre services :
Imaginez :

• Proxy écrit en Go
• Service AuthZ écrit en Python

L'attaquant envoie :

{
"action": "UserAction",
"AcTiOn": "AdminAction"
}

• Python voit UserAction, l'autorise
• Go voit AdminAction, l'exécute

Confusion de format de données (Polyglots)

L'objectif est d'exploiter des systèmes qui mélangent des formats (JSON/XML/YAML) ou échouent en mode ouvert lors d'erreurs de parsing comme :

• CVE-2020-16250 : HashiCorp Vault a analysé JSON avec un parseur XML après que STS a renvoyé JSON au lieu de XML.

L'attaquant contrôle :

• L'en-tête Accept: application/json
• Un contrôle partiel du corps JSON

Le parseur XML de Go l'a analysé quand même et a fait confiance à l'identité injectée.

• Charge utile conçue :

{
"action": "Action_1",
"AcTiOn": "Action_2",
"ignored": "<?xml version=\"1.0\"?><Action>Action_3</Action>"
}

Résultat :

• Go JSON parser : Action_2 (insensible à la casse + dernier gagne)
• YAML parser : Action_1 (sensible à la casse)
• XML parser : analyse "Action_3" à l'intérieur de la chaîne

🔐 Atténuations