Chasser les malwares grand public avec Amcache

Quand vous arrivez sur un hôte Windows qui « sent mauvais » — un utilisateur a signalé un comportement étrange, un EDR a levé une alerte à faible confiance, un journal firewall montre quelque chose que l'hôte ne devrait pas faire — Amcache est l'un des artefacts les plus rapides à vous donner une réponse oui/non sur « y a-t-il du tooling attaquant évident ici ? ».

Cette page est le playbook de triage de malware grand public : les filtres, pivots et requêtes spécifiques qui font ressortir les artefacts attaquants typiques sur le poste de travail typiquement infecté.

Pour le contexte sur l'artefact, voir la référence complète Amcache ; pour combiner Amcache avec d'autres preuves d'exécution, voir Amcache vs Prefetch, Amcache vs ShimCache, et Amcache vs SRUM.

Pourquoi Amcache est le bon premier arrêt#

Trois propriétés font d'Amcache l'artefact naturellement premier dans un triage de malware :

Il enregistre le SHA-1 de chaque PE que l'appraiser a vu. Ce hash va directement dans une requête VirusTotal ou flux TI.
Il enregistre le chemin complet. Le chemin est la moitié de l'histoire pour le triage de malware grand public — tout ce qui est dans \Users\<x>\AppData\Local\Temp\ ou \ProgramData\ est suspect par défaut.
Il survit à la suppression du binaire. Voir Récupérer la preuve de binaires supprimés depuis Amcache.

Ensemble : analyser, filtrer, vérifier les hashes, et vous avez une réponse défendable « cet hôte est-il compromis ? » en quelques minutes.

Le filtre de triage de base#

Appliquez ceci à *_UnassociatedFileEntries.csv en premier, à chaque fois :

Import-Csv .\HOST_amcache_UnassociatedFileEntries.csv |
  Where-Object {
    $_.IsPeFile -eq 'True' -and
    -not $_.Publisher    -and
    $_.FullPath -match '\\Users\\|\\ProgramData\\|\\AppData\\|\\Temp\\|\\Public\\'
  } |
  Select-Object KeyLastWriteTimestamp, FullPath, Hash, Size, LinkDate |
  Sort-Object KeyLastWriteTimestamp -Descending

Ce que cela fait ressortir :

Les binaires PE non signés dans des chemins où un utilisateur normal peut écrire.

Ce qu'il manque (et pour lequel vous avez besoin de filtres de suivi) :

Les binaires signés-mais-malveillants (ransomwares signés, RAT signés).
Les binaires dans des chemins protégés (\Windows\System32\ — nécessiterait des droits admin pour y déposer, mais arrive avec l'élévation de privilèges).
Les binaires living-off-the-land (LOLBINs) — ceux-ci sont signés et légitimement dans \Windows\System32\.

Ce filtre renvoie typiquement 5 à 50 lignes sur un poste de travail typiquement infecté. La plupart sont des faux positifs (applications portables, outils de dev, scripts personnalisés). Triez à partir de là.

Contrôles de faux positifs#

Quelques patterns qui filtrent rapidement les lignes bénignes évidentes :

Exclure les chemins de développeur / applications portables#

$benignPaths = @(
    '\\AppData\\Local\\JetBrains\\',
    '\\AppData\\Local\\Programs\\Microsoft VS Code\\',
    '\\AppData\\Local\\Programs\\Slack\\',
    '\\AppData\\Local\\Programs\\Notion\\',
    '\\AppData\\Roaming\\Spotify\\',
    '\\AppData\\Local\\GitHubDesktop\\',
    '\\AppData\\Local\\Microsoft\\Teams\\',
    '\\AppData\\Local\\Discord\\',
    '\\AppData\\Local\\1Password\\'
)
 
$rows | Where-Object {
    $path = $_.FullPath
    -not ($benignPaths | Where-Object { $path -match $_ })
}

Ajustez la liste à l'outillage standard de développeur / power-user de votre environnement. Une baseline d'« applications portables connues dans les chemins utilisateur » vaut la peine d'être maintenue une fois par environnement.

Exclure les éditeurs connus via le hash#

Si vous avez une liste de hashes known-good (votre allowlist interne, NSRL, le flux clean-hash Cisco Talos), faites la jointure de la colonne Hash d'Amcache avec elle et abandonnez les correspondances.

Exclure les noms de leurre attaquant très communs auxquels vous faites confiance ailleurs#

update.exe, service.exe, svchost.exe dans des chemins utilisateur sont suspects *parce qu'*ils partagent les noms avec des binaires Windows légitimes — les noms seuls ne sont pas le signal ; le chemin + l'éditeur manquant le sont. Le filtre de base attrape déjà ceux-ci.

Patterns attaquants à haute précision#

Une fois que vous avez la liste filtrée, ces patterns sont typiquement des indicateurs à haute précision sur un endpoint Windows typique :

`\AppData\Local\Temp\` + PE + non signé#

C:\Users\bob\AppData\Local\Temp\xyz1234.tmp.exe
C:\Users\bob\AppData\Local\Temp\setup_temp\install.exe

Presque jamais un pattern développeur bénin. Courant pour :

Droppers d'accès initial issus de pièces jointes de phishing.
Payloads de macros Office.
Téléchargements livrés par navigateur qui s'exécutent depuis Temp.

Noms de fichiers suspects qui imitent les composants OS#

C:\Users\Public\Documents\svchost.exe
C:\ProgramData\msmpeng.exe
C:\Users\bob\AppData\Roaming\winupdate.exe

La combinaison d'un nom de style composant-OS et d'un chemin où aucun composant OS ne se trouverait jamais est un indicateur de malware quasi certain.

Clusters de `LinkDate`#

Triez la liste filtrée par LinkDate :

$rows | Sort-Object LinkDate

Cherchez des clusters : 3 à 10 binaires avec des valeurs LinkDate à quelques heures les unes des autres. Les attaquants compilent fréquemment leur boîte à outils complète en une seule session, et les horodatages de link se regroupent. C'est un signal fort « c'est une seule campagne ».

Correspondances `Hash`-seul dans `Unassociated`#

Prenez chaque Hash de vos lignes filtrées et vérifiez s'il apparaît n'importe où dans *_AssociatedFileEntries.csv (c'est-à- dire matché à une application installée). Si le même hash apparaît Associated sur cet hôte ou n'importe quel autre hôte collecté, le binaire a un contexte bénin-ou-suivi ailleurs. S'il n'apparaît que Unassociated et seulement sur ce seul hôte, cela augmente la suspicion.

Confirmer l'exécution#

Une ligne dans Amcache signifie que le binaire était sur disque au moment de l'appraiser ; cela ne signifie pas qu'il a tourné. Pour confirmer l'exécution :

Prefetch#

Pour chaque ligne suspecte, vérifiez si C:\Windows\Prefetch\ contient un .pf pour ce binaire :

NOTEPAD.EXE-1A2B3C4D.pf
XYZ1234.TMP.EXE-FEDCBA98.pf

Un .pf est une preuve d'exécution définitive. Analysez Prefetch avec PECmd.exe pour obtenir les horodatages de run. Voir Amcache vs Prefetch pour la comparaison complète.

Security 4688 / Sysmon 1#

Si l'audit de création de processus est activé (il devrait l'être), chaque lancement journalise un événement 4688 ou Sysmon 1 avec la ligne de commande complète. Filtrez sur le chemin du binaire et vous obtenez chaque exécution avec ses arguments — généralement le point de donnée unique le plus utile dans un triage de malware.

SRUM#

Si le binaire a utilisé du CPU ou du réseau mesurable, SRUM (SRUDB.dat) a une ligne au niveau heure pour lui. Voir Amcache vs SRUM. Particulièrement utile pour l'activité réseau — si SRUM montre que le binaire a envoyé des gigaoctets d'octets réseau, c'est votre timeline d'exfiltration de données.

Délimiter l'incident sur plusieurs hôtes#

Une fois que vous avez confirmé au moins un binaire malveillant sur un hôte, la question devient : où d'autre cela existe-t-il ?

Pivot par hash sur les Amcache collectés#

$badHashes = @('da39a3ee5e6b4b0d3255bfef95601890afd80709',
               '1234567890abcdef1234567890abcdef12345678')
 
Get-ChildItem -Recurse -Filter *_UnassociatedFileEntries.csv |
  ForEach-Object {
    $host = $_.PSChildName.Split('_')[0]
    Import-Csv $_.FullName |
      Where-Object { $badHashes -contains $_.Hash } |
      Select-Object @{n='Host';e={$host}}, FullPath, KeyLastWriteTimestamp
  } |
  Sort-Object KeyLastWriteTimestamp

Cela vous dit chaque hôte collecté qui a déjà eu l'un des hashes malveillants, trié par heure vue par l'appraiser. Révèle souvent le patient zero (horodatage le plus ancien) et la propagation (horodatages suivants sur d'autres hôtes).

Pivot par `ProgramId` pour les familles d'outils#

$badProgramIds = @('0006fa0b2a9f8a4eb9d7c81e8b1f3c5d3e2a0000ffff')
 
Get-ChildItem -Recurse -Filter *_UnassociatedFileEntries.csv |
  ForEach-Object {
    $host = $_.PSChildName.Split('_')[0]
    Import-Csv $_.FullName |
      Where-Object { $badProgramIds -contains $_.ProgramId } |
      Select-Object @{n='Host';e={$host}}, FullPath, Hash, KeyLastWriteTimestamp
  }

ProgramId attrape les correspondances au niveau famille que Hash manque (rebuilds avec les mêmes métadonnées). Voir ProgramId Amcache expliqué.

Pivot par pattern de chemin#

Get-ChildItem -Recurse -Filter *_UnassociatedFileEntries.csv |
  ForEach-Object {
    $host = $_.PSChildName.Split('_')[0]
    Import-Csv $_.FullName |
      Where-Object {
        $_.FullPath -match '\\AppData\\Roaming\\[a-z0-9]{8}\\update\.exe$'
      } |
      Select-Object @{n='Host';e={$host}}, FullPath, Hash, KeyLastWriteTimestamp
  }

Pour les patterns de chemin attaquant connus (un emplacement d'installation spécifique qu'un intrusion set utilise), pivotez par regex de chemin plutôt que par hash.

Le flux de triage complet#

Un flux end-to-end reproductible :

Collecter Amcache (Amcache.hve + .LOG1 + .LOG2) depuis l'hôte suspect.
Analyser avec AmcacheParser.exe --mp.
Appliquer le filtre de base à *_UnassociatedFileEntries.csv.
Appliquer les contrôles de faux positifs (applications portables connues, hashes d'allowlist).
Trier le restant — VirusTotal chaque Hash, regarder les chemins et noms suspects.
Confirmer l'exécution via Prefetch / 4688 / Sysmon pour chaque ligne confirmée malveillante.
Borner dans le temps l'incident : prendre le KeyLastWriteTimestamp le plus ancien et l'heure de run Prefetch la plus récente ; cette fenêtre est votre intervalle d'incident.
Délimiter la propagation via les pivots hash / ProgramId sur tous les fichiers Amcache collectés.
Confirmer le nettoyage : ré-exécuter après containment pour vérifier que les lignes malveillantes n'ont plus de nouvelles exécutions Prefetch correspondantes.

Ce flux prend des heures, pas des jours, et fonctionne sur la grande majorité des engagements de malware grand public sans EDR spécialisé.

Voir aussi#

Référence complète Amcache — l'artefact en intégralité.
Amcache vs Prefetch — compagnon de preuve d'exécution.
FileId Amcache expliqué — format de hash pour recherches VT.
ProgramId Amcache expliqué — le pivot famille cross-hôtes.
Récupérer la preuve de binaires supprimés depuis Amcache — quand le binaire lui-même est parti.
Mouvement latéral et pivot avec le ProgramId Amcache — délimiter la propagation dans l'environnement.

Pour trier une ruche tout de suite sans rien installer, déposez le fichier sur la page d'accueil de l'analyseur — elle s'analyse entièrement dans votre navigateur.