Análise de Arquivos Prefetch para Histórico de Execução

Analisando Arquivos Prefetch para Histórico de Execução

Quando Usar

• Quando for necessário determinar quais programas foram executados em um sistema Windows e quando
• Durante investigações de malware para confirmar a execução de binários suspeitos
• Para estabelecer uma linha do tempo de uso de aplicativos durante um incidente
• Ao correlacionar a execução de programas com outros artefatos forenses
• Para identificar ferramentas anti-forenses ou software não autorizado que foi executado

Pré-requisitos

• Acesso ao diretório Prefetch do Windows (C:\Windows\Prefetch) a partir de uma imagem forense
• PECmd (Eric Zimmerman), WinPrefetchView ou um analisador python-prefetch
• Compreensão do formato do arquivo Prefetch (versões 17, 23, 26, 30)
• Sistema Windows com Prefetch habilitado (padrão em sistemas cliente, desabilitado em servidores)
• Conhecimento das convenções de nomenclatura do Prefetch (APPNAME-HASH.pf)

Fluxo de Trabalho

Passo 1: Extrair Arquivos Prefetch da Imagem Forense

# Montar a imagem forense
mount -o ro,loop,offset=$((2048*512)) /cases/case-2024-001/images/evidence.dd /mnt/evidence

# Copiar todos os arquivos prefetch
mkdir -p /cases/case-2024-001/prefetch/
cp /mnt/evidence/Windows/Prefetch/*.pf /cases/case-2024-001/prefetch/

# Contar e listar arquivos prefetch
ls -la /cases/case-2024-001/prefetch/ | wc -l
ls -la /cases/case-2024-001/prefetch/ | head -30

# Calcular hashes de todos os arquivos prefetch para integridade
sha256sum /cases/case-2024-001/prefetch/*.pf > /cases/case-2024-001/prefetch/pf_hashes.txt

# Nota: O formato do nome do arquivo Prefetch é NOME_EXECUTAVEL-XXXXXXXX.pf
# O hash (XXXXXXXX) é baseado no caminho do executável
# O mesmo executável de caminhos diferentes cria arquivos prefetch diferentes

Passo 2: Analisar Arquivos Prefetch com PECmd

# Usando PECmd de Eric Zimmerman (Windows ou via Mono/Wine no Linux)
# Download em https://ericzimmerman.github.io/

# Analisar um único arquivo prefetch
PECmd.exe -f "C:\cases\prefetch\POWERSHELL.EXE-A]B2C3D4.pf"

# Analisar todos os arquivos prefetch e gerar saída CSV
PECmd.exe -d "C:\cases\prefetch\" --csv "C:\cases\analysis\" --csvf prefetch_results.csv

# Analisar com saída JSON
PECmd.exe -d "C:\cases\prefetch\" --json "C:\cases\analysis\" --jsonf prefetch_results.json

# A saída inclui para cada arquivo:
# - Nome e caminho do executável
# - Contagem de execuções
# - Último horário de execução (até 8 timestamps no Windows 10)
# - Arquivos e diretórios referenciados durante a execução
# - Informações de volume (número de série, data de criação)
# - Data de criação do arquivo Prefetch

Passo 3: Analisar com Python para Análise Baseada em Linux

pip install prefetch

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

# Analisa arquivos prefetch usando python
import struct

def parse_prefetch(filepath):
    """Analisa um arquivo Windows Prefetch."""
    with open(filepath, 'rb') as f:
        data = f.read()

    # Verifica formato comprimido MAM (Windows 10)
    if data[:4] == b'MAM\x04':
        import lznt1  # ou use DecompressBuffer
        # Arquivos prefetch do Windows 10 são comprimidos
        print(f"  [Formato Win10 comprimido - use PECmd para análise completa]")
        return None

    # Versão 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"  Assinatura Prefetch inválida")
        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,
    }

    # Extrai timestamps de última execução
    if version == 23:  # Vista/7 - 1 timestamp
        ts = struct.unpack('<Q', data[128:136])[0]
        result['last_run'] = filetime_to_datetime(ts)
    elif version >= 26:  # Win8+ - até 8 timestamps
        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):
    """Converte Windows FILETIME em string 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

# Processa todos os arquivos 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"  Executável: {result['executable']}")
            print(f"  Execuções:  {result['run_count']}")
            if 'last_run' in result:
                print(f"  Último Run: {result['last_run']}")
            elif 'last_run_times' in result:
                for i, ts in enumerate(result['last_run_times']):
                    print(f"  Execução {i+1}: {ts}")
            results.append(result)

# Salva resultados
with open('/cases/case-2024-001/analysis/prefetch_analysis.json', 'w') as f:
    json.dump(results, f, indent=2)
PYEOF

Passo 4: Identificar Evidências de Execução Suspeita

# Procurar por nomes de ferramentas maliciosas conhecidas nos prefetch
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(MIMIKATZ|PSEXEC|WMIC|COBALT|BEACON|PWDUMP|PROCDUMP|LAZAGNE|RUBEUS|BLOODHOUND|SHARPHOUND|CERTUTIL|BITSADMIN)'

# Procurar por interpretadores de script (potencial execução maliciosa)
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(POWERSHELL|CMD\.EXE|WSCRIPT|CSCRIPT|MSHTA|REGSVR32|RUNDLL32|MSIEXEC)'

# Procurar por ferramentas de acesso remoto
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(TEAMVIEWER|ANYDESK|LOGMEIN|VNC|SPLASHTOP|SCREENCONNECT|AMMYY)'

# Procurar por ferramentas de exfiltração de dados
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(RAR|7Z|ZIP|RCLONE|MEGA|DROPBOX|ONEDRIVE|GDRIVE|FTP|CURL|WGET)'

# Encontrar arquivos prefetch criados recentemente (executáveis mais novos)
ls -lt /cases/case-2024-001/prefetch/ | head -20

# Correlacionar com Shimcache e Amcache para confirmação
# Existência de Prefetch = programa foi executado pelo menos uma vez

Passo 5: Construir Linha do Tempo de Execução

# Criar linha do tempo a partir dos dados 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'
        })

# Ordenar cronologicamente
timeline.sort(key=lambda x: x['timestamp'])

# Escrever CSV da linha do tempo
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)

# Imprimir janela de tempo suspeita
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

Conceitos Chave

Conceito	Descrição
Prefetch	Otimização de desempenho do Windows que pré-carrega dados de aplicativos e rastreia execução
Assinatura SCCA	Bytes mágicos que identificam um arquivo Prefetch válido
Hash do caminho	Hash baseado em CRC do caminho do executável formando parte do nome do arquivo .pf
Contagem de execuções	Número de vezes que o executável foi iniciado (pode sofrer wrap)
Timestamps de última execução	Windows 8+ armazena até 8 timestamps de execução mais recentes
Arquivos referenciados	Lista de arquivos e diretórios acessados durante os primeiros 10 segundos de execução
Informações de volume	Número de série da unidade e data de criação identificando o volume de origem
Compressão MAM	Arquivos Prefetch do Windows 10 usam compressão MAM4 que requer descompressão antes da análise

Ferramentas e Sistemas

Ferramenta	Finalidade
PECmd	Analisador Prefetch de Eric Zimmerman com saída CSV/JSON
WinPrefetchView	Ferramenta GUI NirSoft para visualizar arquivos Prefetch
python-prefetch	Biblioteca Python para analisar arquivos Prefetch
Calculadora de Hash Prefetch	Ferramenta para calcular o hash esperado a partir de caminhos de executáveis
KAPE	Coleta automatizada de artefatos, incluindo Prefetch
Autopsy	Plataforma forense com módulo de análise Prefetch
Plaso/log2timeline	Ferramenta de super-linha do tempo que inclui analisador Prefetch
Velociraptor	Agente de endpoint com artefatos de coleta e análise Prefetch

Cenários Comuns

Cenário 1: Confirmar Execução de Malware Pesquise no diretório Prefetch pelo nome do executável do malware, confirme a execução pela existência do Prefetch, extraia a contagem de execuções e o último horário, identifique DLLs referenciadas para entender o comportamento do malware, correlacione com entradas de inicialização automática do registro.

Cenário 2: Linha do Tempo de Uso de Ferramentas do Atacante Identifique arquivos Prefetch para PsExec, Mimikatz, BloodHound e outras ferramentas do atacante, construa uma linha do tempo cronológica da execução das ferramentas, determine a sequência do ataque (reconhecimento, roubo de credenciais, movimento lateral), combine timestamps com logs de conexão de rede.

Cenário 3: Estágio e Exfiltração de Dados Procure entradas Prefetch de ferramentas de compressão (7z, WinRAR, zip), identifique execução de utilitários de transferência de arquivos (rclone, clientes FTP), verifique execução de clientes de armazenamento em nuvem, timeline de quando o estágio e a transferência de dados ocorreram.

Cenário 4: Detecção Anti-Forense Verifique a execução de ferramentas anti-forenses conhecidas (CCleaner, Eraser, SDelete), identifique se o diretório Prefetch foi limpo recentemente (menos arquivos do que o esperado para um sistema ativo), observe timestamps de execução de ferramentas anti-forenses em relação a outras evidências.

Formato de Saída

Resumo da Análise Prefetch:
  Sistema: Windows 10 Pro (Build 19041)
  Arquivos Prefetch: 234
  Período de Análise: Todo o histórico de execução disponível

  Estatísticas de Execução:
    Total de executáveis únicos: 234
    Primeira execução: 2023-06-15 (instalação do sistema)
    Última execução: 2024-01-18 23:45 UTC

  Execuções Suspeitas:
    MIMIKATZ.EXE-5F2A3B1C.pf
      Execuções: 3 | Última: 2024-01-16 02:30:15 UTC
    PSEXEC.EXE-AD70946C.pf
      Execuções: 7 | Última: 2024-01-16 02:45:30 UTC
    RCLONE.EXE-1F3E5A2B.pf
      Execuções: 2 | Última: 2024-01-17 03:15:00 UTC
    POWERSHELL.EXE-022A1004.pf
      Execuções: 145 | Última: 2024-01-18 14:00:00 UTC

  Linha do Tempo do Ataque (a partir do Prefetch):
    2024-01-15 14:32 - POWERSHELL.EXE (acesso inicial)
    2024-01-16 02:30 - MIMIKATZ.EXE (roubo de credenciais)
    2024-01-16 02:45 - PSEXEC.EXE (movimento lateral)
    2024-01-17 03:15 - RCLONE.EXE (exfiltração de dados)

  Relatório: /cases/case-2024-001/analysis/execution_timeline.csv