Communitygithub.com

Analyse des fichiers Prefetch pour l'historique d'exécution

Analysez les fichiers Prefetch Windows (versions 17, 23, 26, 30) avec des outils comme PECmd, WinPrefetchView ou python-prefetch pour déterminer l'historique d'exécution des programmes, y compris le nombre d'exécutions, les horodatages et les fichiers/DLL référencés.

Qu'est-ce que Analyse des fichiers Prefetch pour l'historique d'exécution ?

Cette compétence permet aux enquêteurs forensiques et aux analystes de sécurité de transformer les binaires Prefetch Windows (situés dans C:\Windows\Prefetch\) en preuves exploitables sur l'historique d'exécution des programmes. Elle supporte les versions de format 17 (XP), 23 (Vista/7), 26 (8.1) et 30 (Windows 10/11), avec des instructions détaillées pour des outils comme PECmd (Eric Zimmerman), WinPrefetchView et la bibliothèque Python `prefetch`. L'utilisateur peut identifier les exécutions de malwares (Mimikatz, PsExec, etc.), les outils d'anti-forensique, les utilitaires d'exfiltration de données, et les interpréteurs de script suspects. Le flux de travail inclut l'extraction des fichiers .pf depuis une image forensique, leur parsing (avec extraction du nombre d'exécutions, des 8 derniers horodatages d'exécution sous Windows 10, des fichiers référencés), la recherche de noms d'exécutables suspects, et la construction d'une timeline d'exécution au format CSV. Les concepts clés (Signature SCCA, hachage de chemin, compression MAM) sont expliqués, ainsi que des scénarios courants comme la confirmation d'exécution de malwares, la cartographie des outils d'attaquants, l'exfiltration de données et la détection d'anti-forensique.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/mukul975/Anthropic-Cybersecurity-Skills/tree/main/skills/analyzing-prefetch-files-for-execution-history
Voir l'original→Voir toutes les compétences

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

OpenAIChatGPTClaudeClaudeGeminiGeminiGrokGrokPerplexityPerplexityDeepSeekDeepSeek

Documentation

Que fait Analyse des fichiers Prefetch pour l'historique d'exécution ?

Quand l'utiliser

  • Lors de la détermination des programmes exécutés sur un système Windows et de leur date d'exécution
  • Lors d'enquêtes sur des malwares pour confirmer l'exécution de binaires suspects
  • Pour établir une chronologie d'utilisation des applications lors d'un incident
  • Lors de la corrélation de l'exécution de programmes avec d'autres artéfacts forensiques
  • Pour identifier des outils anti-forensiques ou des logiciels non autorisés qui ont été exécutés

Prérequis

  • Accès au répertoire Prefetch Windows (C:\Windows\Prefetch) à partir d'une image forensique
  • PECmd (Eric Zimmerman), WinPrefetchView ou un analyseur python-prefetch
  • Compréhension du format des fichiers Prefetch (versions 17, 23, 26, 30)
  • Système Windows avec Prefetch activé (par défaut sur les OS clients, désactivé sur les serveurs)
  • Connaissance des conventions de nommage Prefetch (APPNAME-HASH.pf)

Workflow

Étape 1 : Extraire les fichiers Prefetch de l'image forensique

# Monter l'image forensique
mount -o ro,loop,offset=$((2048*512)) /cases/case-2024-001/images/evidence.dd /mnt/evidence

# Copier tous les fichiers prefetch
mkdir -p /cases/case-2024-001/prefetch/
cp /mnt/evidence/Windows/Prefetch/*.pf /cases/case-2024-001/prefetch/

# Compter et lister les fichiers prefetch
ls -la /cases/case-2024-001/prefetch/ | wc -l
ls -la /cases/case-2024-001/prefetch/ | head -30

# Hacher tous les fichiers prefetch pour l'intégrité
sha256sum /cases/case-2024-001/prefetch/*.pf > /cases/case-2024-001/prefetch/pf_hashes.txt

# Remarque : le format du nom de fichier Prefetch est NOM_EXECUTABLE-XXXXXXXX.pf
# Le hachage (XXXXXXXX) est basé sur le chemin de l'exécutable
# Un même exécutable provenant de chemins différents crée différents fichiers prefetch

Étape 2 : Analyser les fichiers Prefetch avec PECmd

# Utilisation de PECmd d'Eric Zimmerman (Windows ou via Mono/Wine sur Linux)
# Téléchargement sur https://ericzimmerman.github.io/

# Analyser un seul fichier prefetch
PECmd.exe -f "C:\cases\prefetch\POWERSHELL.EXE-A]B2C3D4.pf"

# Analyser tous les fichiers prefetch et exporter en CSV
PECmd.exe -d "C:\cases\prefetch\" --csv "C:\cases\analysis\" --csvf prefetch_results.csv

# Analyser avec sortie JSON
PECmd.exe -d "C:\cases\prefetch\" --json "C:\cases\analysis\" --jsonf prefetch_results.json

# La sortie inclut pour chaque fichier :
# - Nom et chemin de l'exécutable
# - Nombre d'exécutions
# - Dernier horodatage d'exécution (jusqu'à 8 horodatages dans Windows 10)
# - Fichiers et répertoires référencés lors de l'exécution
# - Informations sur le volume (numéro de série, date de création)
# - Date de création du fichier Prefetch

Étape 3 : Analyser avec Python pour une analyse sous Linux

pip install prefetch

python3 << 'PYEOF'
import os
import json
from datetime import datetime

# Analyser les fichiers prefetch en utilisant Python
import struct

def parse_prefetch(filepath):
    """Analyse un fichier Prefetch Windows."""
    with open(filepath, 'rb') as f:
        data = f.read()

    # Vérifier le format compressé MAM (Windows 10)
    if data[:4] == b'MAM\x04':
        import lznt1  # ou utiliser DecompressBuffer
        # Les fichiers Prefetch de Windows 10 sont compressés
        print(f"  [Format Win10 compressé - utilisez PECmd pour une analyse complète]")
        return None

    # Version 17 (XP), 23 (Vista/7), 26 (8.1), 30 (10)
    version = struct.unpack('<I', data[0:4])[0]
    signature = data[4:8]

    if signature != b'SCCA':
        print(f"  Signature Prefetch invalide")
        return None

    file_size = struct.unpack('<I', data[8:12])[0]
    exec_name = data[16:76].decode('utf-16-le').strip('\x00')
    run_count = struct.unpack('<I', data[208:212])[0] if version >= 23 else struct.unpack('<I', data[144:148])[0]

    result = {
        'version': version,
        'executable': exec_name,
        'file_size': file_size,
        'run_count': run_count,
    }

    # Extraire les derniers horodatages d'exécution
    if version == 23:  # Vista/7 - 1 horodatage
        ts = struct.unpack('<Q', data[128:136])[0]
        result['last_run'] = filetime_to_datetime(ts)
    elif version >= 26:  # Win8+ - jusqu'à 8 horodatages
        timestamps = []
        for i in range(8):
            ts = struct.unpack('<Q', data[128+i*8:136+i*8])[0]
            if ts > 0:
                timestamps.append(filetime_to_datetime(ts))
        result['last_run_times'] = timestamps

    return result

def filetime_to_datetime(ft):
    """Convertit un FILETIME Windows en chaîne datetime."""
    if ft == 0:
        return None
    timestamp = (ft - 116444736000000000) / 10000000
    try:
        return datetime.utcfromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S UTC')
    except (OSError, ValueError):
        return None

# Traiter tous les fichiers prefetch
prefetch_dir = '/cases/case-2024-001/prefetch/'
results = []

for filename in sorted(os.listdir(prefetch_dir)):
    if filename.lower().endswith('.pf'):
        filepath = os.path.join(prefetch_dir, filename)
        print(f"\n=== {filename} ===")
        result = parse_prefetch(filepath)
        if result:
            print(f"  Exécutable : {result['executable']}")
            print(f"  Nombre d'exécutions : {result['run_count']}")
            if 'last_run' in result:
                print(f"  Dernière exécution : {result['last_run']}")
            elif 'last_run_times' in result:
                for i, ts in enumerate(result['last_run_times']):
                    print(f"  Exécution {i+1} : {ts}")
            results.append(result)

# Sauvegarder les résultats
with open('/cases/case-2024-001/analysis/prefetch_analysis.json', 'w') as f:
    json.dump(results, f, indent=2)
PYEOF

Étape 4 : Identifier les preuves d'exécution suspectes

# Rechercher des noms d'outils malveillants connus dans le prefetch
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(MIMIKATZ|PSEXEC|WMIC|COBALT|BEACON|PWDUMP|PROCDUMP|LAZAGNE|RUBEUS|BLOODHOUND|SHARPHOUND|CERTUTIL|BITSADMIN)'

# Rechercher des interpréteurs de script (exécution malveillante potentielle)
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(POWERSHELL|CMD\.EXE|WSCRIPT|CSCRIPT|MSHTA|REGSVR32|RUNDLL32|MSIEXEC)'

# Rechercher des outils d'accès à distance
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(TEAMVIEWER|ANYDESK|LOGMEIN|VNC|SPLASHTOP|SCREENCONNECT|AMMYY)'

# Rechercher des outils d'exfiltration de données
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(RAR|7Z|ZIP|RCLONE|MEGA|DROPBOX|ONEDRIVE|GDRIVE|FTP|CURL|WGET)'

# Trouver les fichiers prefetch récemment créés (exécutables les plus récents)
ls -lt /cases/case-2024-001/prefetch/ | head -20

# Recouper avec Shimcache et Amcache pour confirmation
# La présence d'un fichier Prefetch = le programme a été exécuté au moins une fois

Étape 5 : Construire une chronologie d'exécution

# Créer une chronologie à partir des données prefetch
python3 << 'PYEOF'
import json
import csv

with open('/cases/case-2024-001/analysis/prefetch_analysis.json') as f:
    data = json.load(f)

timeline = []
for entry in data:
    if 'last_run_times' in entry:
        for ts in entry['last_run_times']:
            if ts:
                timeline.append({
                    'timestamp': ts,
                    'executable': entry['executable'],
                    'run_count': entry['run_count'],
                    'source': 'Prefetch'
                })
    elif 'last_run' in entry and entry['last_run']:
        timeline.append({
            'timestamp': entry['last_run'],
            'executable': entry['executable'],
            'run_count': entry['run_count'],
            'source': 'Prefetch'
        })

# Trier chronologiquement
timeline.sort(key=lambda x: x['timestamp'])

# Écrire le fichier CSV de chronologie
with open('/cases/case-2024-001/analysis/execution_timeline.csv', 'w', newline='') as f:
    writer = csv.DictWriter(f, fieldnames=['timestamp', 'executable', 'run_count', 'source'])
    writer.writeheader()
    writer.writerows(timeline)

# Afficher la fenêtre temporelle suspecte
for entry in timeline:
    if '2024-01-15' in entry['timestamp'] or '2024-01-16' in entry['timestamp']:
        print(f"  {entry['timestamp']} | {entry['executable']} (x{entry['run_count']})")
PYEOF

Concepts clés

ConceptDescription
PrefetchOptimisation des performances Windows qui précharge les données des applications et suit leur exécution
Signature SCCAOctets magiques identifiant un fichier Prefetch valide
Hachage de cheminHachage CRC du chemin de l'exécutable formant une partie du nom de fichier .pf
Nombre d'exécutionsNombre de lancements de l'exécutable (peut dépasser la capacité)
Horodatages de dernière exécutionWindows 8+ stocke jusqu'à 8 horodatages d'exécution les plus récents
Fichiers référencésListe des fichiers et répertoires accédés pendant les 10 premières secondes d'exécution
Informations sur le volumeNuméro de série du disque et date de création identifiant le volume source
Compression MAMLes fichiers Prefetch Windows 10 utilisent la compression MAM4 nécessitant une décompression avant analyse

Outils et systèmes

OutilObjectif
PECmdAnalyseur Prefetch d'Eric Zimmerman avec sortie CSV/JSON
WinPrefetchViewOutil GUI NirSoft pour visualiser les fichiers Prefetch
python-prefetchBibliothèque Python pour analyser les fichiers Prefetch
Prefetch Hash CalculatorOutil pour calculer le hachage attendu à partir des chemins d'exécutables
KAPECollecte automatisée d'artéfacts incluant Prefetch
AutopsyPlateforme forensique avec module d'analyse Prefetch
Plaso/log2timelineOutil de super-chronologie incluant un analyseur Prefetch
VelociraptorAgent de point de terminaison avec des artéfacts de collecte et d'analyse Prefetch

Scénarios courants

Scénario 1 : Confirmer l'exécution d'un malware Recherchez dans le répertoire Prefetch le nom de l'exécutable du malware, confirmez l'exécution via la présence du fichier Prefetch, extrayez le nombre d'exécutions et le dernier horodatage d'exécution, identifiez les DLL référencées pour comprendre le comportement du malware, corrélez avec les entrées de démarrage automatique du registre.

Scénario 2 : Chronologie d'utilisation des outils d'un attaquant Identifiez les fichiers Prefetch pour PsExec, Mimikatz, BloodHound et autres outils d'attaquant, construisez une chronologie chronologique des exécutions d'outils, déterminez la séquence de l'attaque (reconnaissance, vol d'identifiants, mouvement latéral), faites correspondre les horodatages avec les journaux de connexion réseau.

Scénario 3 : Préparation et exfiltration de données Recherchez les entrées Prefetch d'outils de compression (7z, WinRAR, zip), identifiez l'exécution d'utilitaires de transfert de fichiers (rclone, clients FTP), vérifiez l'exécution de clients de stockage cloud, chronométrez les opérations de préparation et de transfert de données.

Scénario 4 : Détection d'anti-forensique Vérifiez l'exécution d'outils anti-forensiques connus (CCleaner, Eraser, SDelete), identifiez si le répertoire Prefetch a récemment été vidé (moins de fichiers que prévu pour un système actif), notez les horodatages des exécutions d'outils anti-forensiques par rapport aux autres preuves.

Format de sortie

Résumé de l'analyse Prefetch :
  Système : Windows 10 Pro (Build 19041)
  Fichiers Prefetch : 234
  Période d'analyse : Tout l'historique d'exécution disponible

  Statistiques d'exécution :
    Total d'exécutables uniques : 234
    Première exécution : 2023-06-15 (installation du système)
    Dernière exécution : 2024-01-18 23:45 UTC

  Exécutions suspectes :
    MIMIKATZ.EXE-5F2A3B1C.pf
      Nombre d'exécutions : 3 | Dernière : 2024-01-16 02:30:15 UTC
    PSEXEC.EXE-AD70946C.pf
      Nombre d'exécutions : 7 | Dernière : 2024-01-16 02:45:30 UTC
    RCLONE.EXE-1F3E5A2B.pf
      Nombre d'exécutions : 2 | Dernière : 2024-01-17 03:15:00 UTC
    POWERSHELL.EXE-022A1004.pf
      Nombre d'exécutions : 145 | Dernière : 2024-01-18 14:00:00 UTC

  Chronologie des attaques (d'après Prefetch) :
    2024-01-15 14:32 - POWERSHELL.EXE (accès initial)
    2024-01-16 02:30 - MIMIKATZ.EXE (vol d'identifiants)
    2024-01-16 02:45 - PSEXEC.EXE (mouvement latéral)
    2024-01-17 03:15 - RCLONE.EXE (exfiltration de données)

  Rapport : /cases/case-2024-001/analysis/execution_timeline.csv

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

abusing-dpapi-for-credential-access

Extract and decrypt Windows DPAPI-protected secrets (Credential Manager, browser logins/cookies, Wi-Fi credentials, KeePass keys) online or offline using SharpDPAPI, SharpChrome, Mimikatz, or Impacket

abusing-shadow-credentials-for-privesc

Take over Active Directory accounts by writing attacker-controlled public keys to msDS-KeyCredentialLink (Shadow Credentials) with pyWhisker, Whisker, or Certipy, then authenticate via PKINIT to recover the target

achieving-cmmc-level-2-compliance

>-

acquiring-disk-image-with-dd-and-dcfldd

Create forensically sound bit-for-bit disk images with dd or dcfldd on a Linux forensic workstation, preserving evidence integrity through hash verification (MD5/SHA) during acquisition. Use when imaging a suspect drive, USB device, or memory card for investigation, preserving volatile disk evidence during incident response, or producing a verified copy for legal or law-enforcement proceedings before any destructive analysis.

analyzing-active-directory-acl-abuse

Detect dangerous ACL misconfigurations in Active Directory using ldap3

analyzing-android-malware-with-apktool

Perform static analysis of Android APK malware using apktool for resource decompilation, jadx for Java source recovery, and androguard for manifest inspection, dangerous permission-combination detection, and identification of obfuscated code, dynamic code loading, and reflection-based API calls. Use to statically triage a suspicious APK without executing it or to build mobile malware detection rules.

analyzing-api-gateway-access-logs

Parses API Gateway access logs (AWS API Gateway, Kong, Nginx) to detect

analyzing-apt-group-with-mitre-navigator

Query ATT&CK data with attackcti, mitreattack-python, and stix2, then build MITRE ATT&CK Navigator layers and multi-layer heatmap overlays mapping one or more APT groups

analyzing-azure-activity-logs-for-threats

Queries Azure Monitor activity logs and sign-in logs via azure-monitor-query

analyzing-bootkit-and-rootkit-samples

Analyzes bootkit and advanced rootkit malware infecting the Master

analyzing-browser-forensics-with-hindsight

Parse Chromium-based browser databases with Hindsight to extract and correlate browsing history, downloads, cookies, cached content, autofill data, saved passwords, and extensions from Chrome, Edge, Brave, Opera, and Vivaldi into a unified timeline (XLSX, JSON, or SQLite output). Use during incident response, insider-threat investigations, or criminal cases when you need to reconstruct a user

analyzing-campaign-attribution-evidence

Systematically evaluate cyber-campaign evidence to attribute an operation to a threat actor, using the Diamond Model and Analysis of Competing Hypotheses (ACH) to weigh infrastructure overlaps, TTP consistency, malware code similarity, and timing/language artifacts into confidence-weighted attribution assessments. Use when an incident investigation needs a defensible attribution confidence level.

analyzing-certificate-transparency-for-phishing

Monitor Certificate Transparency logs using crt.sh and Certstream to

analyzing-cloud-storage-access-patterns

Detect abnormal access in AWS S3, GCS, and Azure Blob Storage by analyzing CloudTrail Data Events, GCS audit logs, and Azure Storage Analytics for after-hours bulk downloads, new-IP access, and API-call spikes (e.g. GetObject) via statistical baselines and time-series anomaly detection. Use when investigating suspected cloud data exfiltration or building related detection rules.

analyzing-cobalt-strike-beacon-configuration

Extract and analyze Cobalt Strike beacon configuration from PE files

analyzing-cobaltstrike-malleable-c2-profiles

Parse and analyze Cobalt Strike Malleable C2 profiles with dissect.cobaltstrike (profiles and beacon-payload configs) and pyMalleableC2 (AST parsing) to extract HTTP/DNS transforms, URIs, headers, sleep/jitter, and injection behavior, then generate network detection signatures. Use when reverse-engineering a captured malleable profile or building detections against Cobalt Strike Beacon traffic.

analyzing-command-and-control-communication

Analyzes malware C2 communication over HTTP, HTTPS, DNS, and custom

analyzing-cyber-kill-chain

Analyzes intrusion activity against the Lockheed Martin Cyber Kill Chain

analyzing-disk-image-with-autopsy

Perform comprehensive forensic analysis of raw (dd), E01, or AFF disk images with Autopsy and The Sleuth Kit, recovering deleted files, examining metadata and embedded artifacts, keyword searching, and building investigation timelines with visual reports. Use for structured analysis of a forensic disk image or when stakeholders need visual reports from evidence.

analyzing-dns-logs-for-exfiltration

Analyzes DNS query logs to detect data exfiltration via DNS tunneling,

Skills associés

steipete/video-frames

Extract frames or short clips from videos using ffmpeg.

community

steipete/summarize

Summarize or transcribe URLs, YouTube/videos, podcasts, articles, transcripts, PDFs, and local files.

community

openclaw/openclaw

Use when testing, fixing, or extending the OpenClaw Control UI GUI with Vitest + Playwright end-to-end checks, mocked Gateway WebSocket flows, mocked dashboard runs, screenshots/videos, or agent-verifiable browser proof.

community

obra/superpowers

Obra superpowers agent skills.

community

affaan-m/ECC

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio...

community

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

community