Communitygithub.com

Análise de Histórico de Conexões de Dispositivos USB

Correlaciona chaves de registro do Windows (USBSTOR, MountedDevices), logs de eventos e artefatos de sistema para investigar o histórico de conexão de dispositivos USB.

O que é Análise de Histórico de Conexões de Dispositivos USB?

Esta skill automatiza a investigação forense de dispositivos USB no Windows, fornecendo um fluxo de trabalho completo para extrair, analisar e correlacionar artefatos de conexão USB. Ela é essencial para detectar exfiltração de dados, rastrear atividades de ameaças internas e auditar a conformidade de políticas de dispositivos removíveis. A skill suporta a análise de imagens forenses ou de hives de registro e logs de eventos coletados de sistemas Windows, utilizando ferramentas como Python, Registry Module, e bibliotecas de parsing de EVTX. O workflow cobre desde a extração de artefatos (hives SYSTEM, SOFTWARE, NTUSER.DAT, logs SetupAPI e Eventos) até a construção de uma linha do tempo unificada e relatório, permitindo identificar dispositivos conectados, letras de unidade atribuídas, timestamps de primeira conexão, e associar o uso a usuários específicos.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/mukul975/Anthropic-Cybersecurity-Skills/tree/main/skills/analyzing-usb-device-connection-history
Ver original→Navegar por todas as habilidades

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

OpenAIChatGPTClaudeClaudeGeminiGeminiGrokGrokPerplexityPerplexityDeepSeekDeepSeek

Documentação

Analisando o Histórico de Conexão de Dispositivos USB

Quando Usar

  • Ao investigar potencial exfiltração de dados via dispositivos de armazenamento removível
  • Durante investigações de ameaças internas para rastrear o uso de dispositivos USB
  • Para auditorias de conformidade que verificam a aplicação de políticas de mídia removível
  • Ao correlacionar conexões USB com eventos de acesso e cópia de arquivos
  • Para estabelecer uma linha do tempo de conexões de dispositivos durante um incidente

Pré-requisitos

  • Imagem forense ou hives de registro e logs de eventos extraídos
  • Acesso aos hives de registro SYSTEM, SOFTWARE e NTUSER.DAT
  • Logs SetupAPI (setupapi.dev.log)
  • Logs de Eventos do Windows (Sistema, Segurança, DriverFrameworks-UserMode)
  • USBDeview, USB Forensic Tracker ou RegRipper
  • Compreensão da identificação de dispositivos USB (VID, PID, número de série)

Fluxo de Trabalho

Passo 1: Extrair Artefatos Relacionados a USB

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

mkdir -p /cases/case-2024-001/usb/

# Hives de registro
cp /mnt/evidence/Windows/System32/config/SYSTEM /cases/case-2024-001/usb/
cp /mnt/evidence/Windows/System32/config/SOFTWARE /cases/case-2024-001/usb/
cp /mnt/evidence/Users/*/NTUSER.DAT /cases/case-2024-001/usb/

# Logs SetupAPI (timestamps da primeira conexão)
cp /mnt/evidence/Windows/INF/setupapi.dev.log /cases/case-2024-001/usb/

# Logs de eventos
cp /mnt/evidence/Windows/System32/winevt/Logs/System.evtx /cases/case-2024-001/usb/
cp "/mnt/evidence/Windows/System32/winevt/Logs/Microsoft-Windows-DriverFrameworks-UserMode%4Operational.evtx" \
   /cases/case-2024-001/usb/ 2>/dev/null
cp "/mnt/evidence/Windows/System32/winevt/Logs/Microsoft-Windows-Partition%4Diagnostic.evtx" \
   /cases/case-2024-001/usb/ 2>/dev/null

Passo 2: Analisar a Chave de Registro USBSTOR

# Extrair entradas USBSTOR do hive SYSTEM
python3 << 'PYEOF'
from Registry import Registry
import json

reg = Registry.Registry("/cases/case-2024-001/usb/SYSTEM")

# Encontrar o ControlSet atual
select = reg.open("Select")
current = select.value("Current").value()
controlset = f"ControlSet{current:03d}"

# Analisar USBSTOR
usbstor_path = f"{controlset}\\Enum\\USBSTOR"
usbstor = reg.open(usbstor_path)

devices = []
print("=== DISPOSITIVOS USBSTOR ===\n")

for device_class in usbstor.subkeys():
    # Formato: Disk&Ven_VENDOR&Prod_PRODUCT&Rev_REVISION
    class_name = device_class.name()
    parts = class_name.split('&')
    vendor = parts[1].replace('Ven_', '') if len(parts) > 1 else 'Desconhecido'
    product = parts[2].replace('Prod_', '') if len(parts) > 2 else 'Desconhecido'
    revision = parts[3].replace('Rev_', '') if len(parts) > 3 else 'Desconhecido'

    for instance in device_class.subkeys():
        serial = instance.name()
        last_write = instance.timestamp()

        device_info = {
            'vendor': vendor,
            'product': product,
            'revision': revision,
            'serial': serial,
            'last_connected': str(last_write),
        }

        # Obter nome amigável se disponível
        try:
            friendly = instance.value("FriendlyName").value()
            device_info['friendly_name'] = friendly
        except:
            pass

        # Obter parâmetros do dispositivo
        try:
            params = instance.subkey("Device Parameters")
            try:
                device_info['class_guid'] = params.value("ClassGUID").value()
            except:
                pass
        except:
            pass

        devices.append(device_info)
        print(f"Dispositivo: {vendor} {product}")
        print(f"  Serial: {serial}")
        print(f"  Última Conexão: {last_write}")
        print(f"  Nome Amigável: {device_info.get('friendly_name', 'N/A')}")
        print()

# Salvar resultados
with open('/cases/case-2024-001/analysis/usb_devices.json', 'w') as f:
    json.dump(devices, f, indent=2)

print(f"\nTotal de dispositivos de armazenamento USB encontrados: {len(devices)}")
PYEOF

Passo 3: Extrair Atribuições de Letras de Unidade e Associações de Usuário

# Analisar MountedDevices do hive SYSTEM
python3 << 'PYEOF'
from Registry import Registry
import struct

reg = Registry.Registry("/cases/case-2024-001/usb/SYSTEM")

mounted = reg.open("MountedDevices")

print("=== DISPOSITIVOS MONTADOS (Atribuições de Letras de Unidade) ===\n")
for value in mounted.values():
    name = value.name()
    data = value.value()

    if name.startswith("\\DosDevices\\"):
        drive_letter = name.replace("\\DosDevices\\", "")
        if len(data) > 24:
            # Dispositivo USB - contém string de caminho do dispositivo
            try:
                device_path = data.decode('utf-16-le').strip('\x00')
                if 'USBSTOR' in device_path or 'USB#' in device_path:
                    print(f"  {drive_letter} -> {device_path}")
            except:
                pass
        else:
            # Disco fixo - contém assinatura do disco + offset
            disk_sig = struct.unpack('<I', data[0:4])[0]
            offset = struct.unpack('<Q', data[4:12])[0]
            print(f"  {drive_letter} -> Assinatura do Disco: 0x{disk_sig:08X}, Offset: {offset}")
PYEOF

# Analisar MountPoints2 do usuário (qual usuário acessou quais dispositivos)
python3 << 'PYEOF'
from Registry import Registry
import os, glob

print("\n=== PONTOS DE MONTAGEM DO USUÁRIO (MountPoints2) ===\n")

for ntuser in glob.glob("/cases/case-2024-001/usb/NTUSER*.DAT"):
    try:
        reg = Registry.Registry(ntuser)
        mp2 = reg.open("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MountPoints2")

        print(f"Hive do usuário: {os.path.basename(ntuser)}")
        for key in mp2.subkeys():
            guid = key.name()
            last_write = key.timestamp()
            if '{' in guid:
                print(f"  Volume: {guid} | Último acesso: {last_write}")
        print()
    except Exception as e:
        print(f"  Erro ao analisar {ntuser}: {e}")
PYEOF

Passo 4: Extrair Timestamps da Primeira Conexão dos SetupAPI

# Analisar setupapi.dev.log para timestamps de primeira instalação de dispositivos USB
python3 << 'PYEOF'
import re

print("=== INSTALAÇÕES DE DISPOSITIVOS USB PELO SETUPAPI ===\n")

with open('/cases/case-2024-001/usb/setupapi.dev.log', 'r', errors='ignore') as f:
    content = f.read()

# Encontrar seções de instalação de dispositivos USB
pattern = r'>>>\s+\[Device Install.*?\n.*?Section start (\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}).*?\n(.*?)<<<'
matches = re.findall(pattern, content, re.DOTALL)

usb_installs = []
for timestamp, section in matches:
    if 'USBSTOR' in section or 'USB\\VID' in section:
        # Extrair ID do dispositivo
        dev_match = re.search(r'(USBSTOR\\[^\s]+|USB\\VID_\w+&PID_\w+[^\s]*)', section)
        if dev_match:
            device_id = dev_match.group(1)
            usb_installs.append({
                'first_install': timestamp,
                'device_id': device_id
            })
            print(f"  {timestamp} | {device_id}")

print(f"\nTotal de instalações USB encontradas: {len(usb_installs)}")
PYEOF

# Analisar Logs de Eventos do Windows para eventos USB
# IDs de Evento: 2003, 2010, 2100, 2102 (DriverFrameworks-UserMode)
# IDs de Evento: 6416 (Segurança - novo dispositivo externo reconhecido)
python3 << 'PYEOF'
import json
from evtx import PyEvtxParser

try:
    parser = PyEvtxParser("/cases/case-2024-001/usb/System.evtx")

    print("\n=== EVENTOS USB DO LOG DE SISTEMA ===\n")
    for record in parser.records_json():
        data = json.loads(record['data'])
        event_id = str(data['Event']['System']['EventID'])

        # Eventos de conexão de dispositivo USB
        if event_id in ('20001', '20003', '10000', '10100'):
            timestamp = data['Event']['System']['TimeCreated']['#attributes']['SystemTime']
            event_data = data['Event'].get('UserData', data['Event'].get('EventData', {}))
            print(f"  [{timestamp}] EventID {event_id}: {json.dumps(event_data, default=str)[:200]}")
except Exception as e:
    print(f"Erro: {e}")
PYEOF

Passo 5: Construir Linha do Tempo e Relatório de Atividade USB

# Compilar todas as evidências USB em uma linha do tempo unificada
python3 << 'PYEOF'
import json, csv

timeline = []

# Carregar dados do USBSTOR
with open('/cases/case-2024-001/analysis/usb_devices.json') as f:
    devices = json.load(f)

for device in devices:
    timeline.append({
        'timestamp': device['last_connected'],
        'source': 'Registro USBSTOR',
        'device': f"{device['vendor']} {device['product']}",
        'serial': device['serial'],
        'event': 'Última Conexão',
        'detail': device.get('friendly_name', '')
    })

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

# Escrever CSV da linha do tempo
with open('/cases/case-2024-001/analysis/usb_timeline.csv', 'w', newline='') as f:
    writer = csv.DictWriter(f, fieldnames=['timestamp', 'source', 'device', 'serial', 'event', 'detail'])
    writer.writeheader()
    writer.writerows(timeline)

print(f"Linha do Tempo USB: {len(timeline)} eventos gravados em usb_timeline.csv")

# Imprimir resumo
print("\n=== RESUMO DE DISPOSITIVOS USB ===")
for entry in timeline:
    print(f"  {entry['timestamp']} | {entry['device']} | {entry['serial'][:20]} | {entry['event']}")
PYEOF

Conceitos Chave

ConceitoDescrição
USBSTORChave de registro que armazena dados de identificação e conexão de dispositivos de armazenamento em massa USB
VID/PIDID do Fabricante e ID do Produto que identificam exclusivamente o fabricante e modelo do dispositivo USB
Número de série do dispositivoIdentificador único para dispositivos USB individuais (alguns dispositivos compartilham números de série)
MountedDevicesChave de registro que mapeia GUIDs de volume e letras de unidade para dispositivos físicos
MountPoints2Chave de registro por usuário mostrando quais volumes um usuário acessou
Log SetupAPILog de instalação de drivers do Windows que registra conexões de dispositivos pela primeira vez
DeviceContainersChave de registro no hive SOFTWARE com metadados e timestamps do dispositivo
EMDMgmtChave de registro que rastreia dispositivos compatíveis com ReadyBoost com números de série e timestamps

Ferramentas e Sistemas

FerramentaPropósito
USB Forensic TrackerFerramenta especializada para extração de histórico de dispositivos USB
USBDeviewFerramenta NirSoft que lista todos os dispositivos USB conectados a um sistema
RegRipper (plugin usbstor)Extração automatizada de artefatos USB a partir de hives de registro
Registry ExplorerAnálise interativa de registro para chaves relacionadas a USB
KAPEColeta automatizada de artefatos relacionados a USB
Plaso/log2timelineCriação de linha do tempo incluindo eventos de conexão USB
FTK ImagerImageamento forense incluindo mídia removível
VelociraptorAgente de endpoint com artefatos de caça a histórico de dispositivos USB

Cenários Comuns

Cenário 1: Exfiltração de Dados por Funcionário em Saída Extraia entradas USBSTOR para identificar todos os dispositivos USB já conectados, correlacione números de série com MountPoints2 para confirmar acesso do usuário, faça referência cruzada de timestamps com logs de acesso a arquivos e arquivos recentes do Jump List, verifique padrões de cópia de arquivos grandes no USN journal.

Cenário 2: Dispositivo Não Autorizado em Sistema Protegido Audite todas as entradas USBSTOR contra uma lista de dispositivos aprovados, identifique dispositivos não autorizados por VID/PID que não correspondem ao hardware aprovado pela empresa, determine quando o dispositivo não autorizado foi conectado pela primeira e última vez, verifique se algum dado foi transferido.

Cenário 3: Distribuição de Malware via USB Identifique o dispositivo USB conectado imediatamente antes da execução do malware (timestamps do Prefetch), extraia o número de série e informações do fabricante, verifique se o autorun estava habilitado para o dispositivo, procure por lançamento de executável a partir da letra da unidade removível no Prefetch e ShimCache.

Cenário 4: Rastreamento de uma Unidade USB Específica em Múltiplos Sistemas Pesquise pelo mesmo número de série do dispositivo no USBSTOR em todas as imagens forenses, construa um mapa de quais sistemas a unidade foi conectada e quando, identifique o caminho cronológico do dispositivo através da organização, correlacione com logs de acesso a compartilhamentos de rede.

Formato de Saída

Análise de Histórico de Dispositivos USB:
  Sistema: DESKTOP-ABC123 (Windows 10 Pro)
  Total de Dispositivos de Armazenamento USB: 12
  Fontes de Análise: USBSTOR, MountedDevices, MountPoints2, SetupAPI, Logs de Eventos

  Inventário de Dispositivos:
    1. Kingston DataTraveler 3.0 (Serial: 0019E06B4521A2B0)
       Primeira Conexão:  2024-01-10 09:15:32 (SetupAPI)
       Última Conexão:   2024-01-18 14:30:00 (USBSTOR)
       Letra de Unidade:     E:
       Acesso do Usuário:      usuario_suspeito (MountPoints2)

    2. WD My Passport (Serial: 575834314131363035)
       Primeira Conexão:  2024-01-15 20:00:00
       Última Conexão:   2024-01-15 23:45:00
       Letra de Unidade:     F:
       Acesso do Usuário:      usuario_suspeito

  Achados Suspeitos:
    - Unidade Kingston conectada 15 vezes durante o período de investigação
    - WD Passport conectado apenas uma vez, no final da noite (horário incomum)
    - Dispositivo desconhecido (VID_1234&PID_5678) conectado em 2024-01-17, sem dispositivo aprovado correspondente

  Linha do Tempo: /cases/case-2024-001/analysis/usb_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,

Habilidades Relacionadas

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