Pular para o conteúdo
Skillpedia
Análise e planilhas35 mil · #5800

hunting-for-lolbins-execution-in-endpoint-logs

Faz seu agente procurar o uso indevido de binários do sistema (LOLBins). É útil para analisar logs de processos em busca de evasão de defesa ou execução de código malicioso.

O que ela faz

Esta ferramenta procura por programas legítimos do Windows que estão sendo usados de forma maliciosa para enganar as defesas. Ela analisa como esses programas são executados para encontrar atividades suspeitas.

Quando usar

  • ✓Ao investigar se programas comuns do Windows foram usados em um ataque.
  • ✓Quando você suspeita que um ataque está tentando se esconder usando ferramentas do sistema.
  • ✓Para verificar se seu sistema de segurança consegue detectar o uso indevido dessas ferramentas.

Exemplo do que pedir para a IA

“Procure por usos suspeitos de certutil, mshta, rundll32 ou regsvr32 nos logs de processos.”

Quer saber mais? Abra as seções abaixo.

Como usar

O jeito mais fácil: copie a mensagem abaixo e cole no Claude, ChatGPT, Cursor ou outra IA. Ela lê a skill e segue as instruções.

Link da skill

https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/hunting-for-lolbins-execution-in-endpoint-logs/SKILL.md

Mensagem pronta para colar

Use esta skill para me ajudar: https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/hunting-for-lolbins-execution-in-endpoint-logs/SKILL.md Leia o arquivo SKILL.md desse link e siga as instruções dele na minha tarefa.
Como funciona

Ela funciona comparando como os programas deveriam ser usados normalmente com como eles estão sendo usados nos logs. Se houver um padrão incomum, como um programa sendo chamado de um local estranho ou com comandos diferentes, isso pode indicar um problema.

Instalação

Jeito mais fácil: copie o link da skill e cole no Claude, ChatGPT ou Cursor pedindo para seguir as instruções.

No terminal (Claude Code, Codex, Cursor), na pasta do projeto:

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill hunting-for-lolbins-execution-in-endpoint-logs

Ou baixe só o arquivo:

curl -L https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/main/skills/hunting-for-lolbins-execution-in-endpoint-logs/SKILL.md -o SKILL.md
Conteúdo técnico (SKILL.md)

Tradução do texto original do autor no GitHub. Os comandos e códigos estão como no original.

Caçando Execuções de LOLBins em Logs de Endpoint

Quando Usar

  • Ao caçar técnicas de ataque "fileless" que abusam de binários nativos do Windows.
  • Após inteligência de ameaças indicar campanhas baseadas em LOLBins visando sua indústria.
  • Ao investigar alertas de uso suspeito de certutil, mshta, rundll32 ou regsvr32.
  • Durante exercícios de "purple team" testando a detecção de técnicas de evasão de defesa.
  • Ao avaliar a cobertura de detecção de endpoint para sub-técnicas do MITRE ATT&CK T1218.

Pré-requisitos

  • Sysmon Event ID 1 (Criação de Processo) com log completo da linha de comando.
  • Windows Security Event ID 4688 com auditoria de linha de comando habilitada.
  • Telemetria de EDR com relacionamentos de processo pai-filho.
  • Plataforma SIEM para consulta e correlação (Splunk, Elastic, Microsoft Sentinel).
  • Referência do projeto LOLBAS (lolbas-project.github.io) para padrões de abuso conhecidos.

Fluxo de Trabalho

  1. Construir Lista de Observação de LOLBins: Compile uma lista de LOLBins de alto risco do projeto LOLBAS, priorizando: certutil.exe, mshta.exe, rundll32.exe, regsvr32.exe, msbuild.exe, installutil.exe, cmstp.exe, wmic.exe, wscript.exe, cscript.exe, bitsadmin.exe e powershell.exe.
  2. Estabelecer Uso Normal (Baseline): Defina como é o uso normal de LOLBins em seu ambiente, perfilando argumentos de linha de comando, processos pais e contextos de usuário para cada binário ao longo de 30 dias.
  3. Caçar por Argumentos Anômalos: Procure por LOLBins executados com argumentos de linha de comando incomuns que indiquem abuso -- certutil com -urlcache -decode -encode, mshta com argumentos de URL, rundll32 carregando DLLs de diretórios temporários/de usuário, regsvr32 com /s /n /u /i:URL.
  4. Analisar Relacionamentos Pai-Filho: Identifique processos pais inesperados que iniciam LOLBins -- por exemplo, outlook.exe iniciando mshta.exe, ou winword.exe iniciando certutil.exe indica entrega de documento "weaponized".
  5. Verificar Execução de Caminhos Incomuns: LOLBins executados de caminhos não padrão (cópias colocadas em %TEMP%, diretórios de perfil de usuário) sugerem abuso de binários renomeados.
  6. Correlacionar com Atividade de Rede: Mapeie a execução de LOLBins para conexões de rede de saída (Sysmon Event ID 3) para identificar "download cradles" e callbacks de C2.
  7. Pontuar e Priorizar: Classifique os achados pela gravidade da anomalia, combinando argumentos suspeitos, processo pai incomum, caminho não padrão e indicadores de atividade de rede.

Conceitos Chave

Conceito Descrição
T1218 Execução de Proxy de Binário do Sistema
T1218.001 Arquivo HTML Compilado (mshta.exe)
T1218.003 CMSTP
T1218.005 Mshta
T1218.010 Regsvr32 (Squiblydoo)
T1218.011 Rundll32
T1127.001 MSBuild
T1197 Tarefas BITS (bitsadmin.exe)
T1140 Desofuscar/Decodificar Arquivos (certutil.exe)
T1059.001 PowerShell
T1059.005 Visual Basic (wscript/cscript)
LOLBAS Projeto Living Off the Land Binaries, Scripts and Libraries

Ferramentas e Sistemas

Ferramenta Propósito
Sysmon Criação de processo com log de linha de comando e hash
CrowdStrike Falcon EDR com análises de detecção de LOLBin
Microsoft Defender for Endpoint Detecção nativa de abuso de LOLBin
Splunk Caça de processos e detecção de anomalias baseada em SPL
Elastic Security Regras de detecção de LOLBin pré-construídas
Projeto LOLBAS Banco de dados de referência de técnicas de abuso de LOLBin
Sigma Rules Regras de detecção comunitárias para abuso de LOLBin

Consultas de Detecção

Splunk -- Execução de LOLBin de Alto Risco

index=sysmon EventCode=1
| where match(Image, "(?i)(certutil|mshta|rundll32|regsvr32|msbuild|installutil|cmstp|bitsadmin)\.exe$")
| eval suspicious=case(
    match(CommandLine, "(?i)certutil.*(-urlcache|-decode|-encode)"), "certutil_download_decode",
    match(CommandLine, "(?i)mshta.*(http|https|javascript|vbscript)"), "mshta_remote_exec",
    match(CommandLine, "(?i)rundll32.*\\\\(temp|appdata|users)"), "rundll32_unusual_dll",
    match(CommandLine, "(?i)regsvr32.*/s.*/n.*/u.*/i:"), "regsvr32_squiblydoo",
    match(CommandLine, "(?i)msbuild.*\\\\(temp|appdata|users)"), "msbuild_unusual_project",
    match(CommandLine, "(?i)bitsadmin.*/transfer"), "bitsadmin_download",
    match(CommandLine, "(?i)cmstp.*/s.*/ni"), "cmstp_uac_bypass",
    1=1, "normal"
)
| where suspicious!="normal"
| table _time Computer User Image CommandLine ParentImage ParentCommandLine suspicious

KQL -- Caça de LOLBin no Microsoft Sentinel

DeviceProcessEvents
| where Timestamp > ago(7d)

…
Perguntas frequentes

O que são 'LOLBins'?

LOLBins é a sigla para 'Living Off the Land Binaries', que são programas legítimos do Windows que atacantes usam para realizar ações maliciosas sem precisar instalar novas ferramentas.

Quais programas são considerados LOLBins?

Exemplos comuns incluem certutil.exe, mshta.exe, rundll32.exe, regsvr32.exe, entre outros listados na referência do projeto LOLBAS.

O que é o MITRE T1218?

É uma classificação do MITRE ATT&CK que descreve técnicas onde atacantes usam binários do sistema para executar código malicioso, muitas vezes para evitar detecção.

Detalhes

Descrição original do autor

Hunts for LOLBins (Living Off the Land Binaries) abuse, mapped to MITRE T1218, by analyzing endpoint process-creation logs for suspicious execution patterns of legitimate Windows system binaries used for malicious purposes. Use when reviewing endpoint process telemetry for LOLBins-based defense evasion or building detections for signed-binary proxy execution.

repo: mukul975/Anthropic-Cybersecurity-Skills

Popularidade

Estrelas no GitHub
35 mil
Posição no ranking
#5800
Licença
Apache-2.0
Atualizada em
31/08/2026

Essa skill é útil?

0

Entre para votar.

Comentários

  • …

Mais skills deste repositório

Skills parecidas