ThreatHunting-Keywords

🎯 Lista de palavras-chave para sessões de ThreatHunting

imagem

Índice

O que é Threat Hunting ?
Arquivos
ThreatHunting-Keywords para a equipe azul (blueteam)
ThreatHunting-Keywords para a equipe vermelha (redteam)
Conteúdo do lookup
Caçar com um SIEM
Caçar sem um SIEM
- Caça otimizada para DFIR
- Regras YARA
Site
Falsos positivos esperados
Regras SIGMA
contribuir

O que é Threat Hunting ?

imagem

Threat hunting é uma abordagem proativa e iterativa para detectar atividades maliciosas na rede ou nos sistemas de uma organização que possam ter contornado as medidas de segurança automatizadas. Diferentemente de investigações reativas disparadas por alertas de segurança, o threat hunting é impulsionado por verificações orientadas por threat intelligence (TI) e por hipóteses derivadas de análise sistemática e oportunística. Essas hipóteses 💡 ajudam os caçadores a descobrir ameaças desconhecidas, ameaças potenciais ou ameaças conhecidas que podem ter escapado das detecções de segurança, bem como vulnerabilidades ou indicadores de comprometimento (IoCs) que sistemas automatizados podem deixar passar ou excluir. O processo também se concentra em identificar precursores de alertas/dashboards, melhorar os fluxos de trabalho de SOC/triagem, contribuir para o gerenciamento do inventário de ativos ocultos e escalar eventos de baixa/média fidelidade que exigem investigação adicional. O objetivo principal é identificar as táticas, técnicas e procedimentos (TTPs) usados por atores de ameaças, aumentando a capacidade da organização de detectar e mitigar preventivamente ataques potenciais.

Vantagens do Threat Hunting:

🔍 Identificar lacunas de visibilidade
- Detecta áreas onde o monitoramento e a detecção são insuficientes, abordando pontos cegos na rede ou nos sistemas para mitigar ameaças ocultas.
🛠️ Preenche lacunas de detecção
- Busca proativamente anomalias, precursores e TTPs que podem não acionar alertas
⚙️ Melhora a eficiência do SOC
- Integra os insights do threat hunting aos fluxos de trabalho do SOC para revelar eventos que as detecções estáticas podem não perceber. Ao reduzir falsos positivos e escalar eventos negligenciados, permite que os analistas de SOC se concentrem em ameaças críticas e refinem a lógica de detecção para uso futuro.
🚀 Aprimora a detecção de ameaças e apoia a melhoria contínua
- Identifica ameaças avançadas, desconhecidas ou ocultas que contornam os sistemas automatizados de detecção e realimenta os processos do SOC com dados valiosos, melhorando ferramentas, treinamento e capacidades futuras de detecção
🛡️ Reduz a superfície de ataque
- Descobre sistemas, aplicativos e shadow IT não gerenciados ou não autorizados na rede, permitindo que as organizações corrijam pontos cegos de segurança e reduzam a exposição a ameaças potenciais.

Integrando o Threat Hunting aos Serviços Principais

imagem

Ciclo de Vida do Threat Hunting nas Operações de SOC

Minha sugestão de processo para organizar sessões de threat hunting parcialmente automatizadas e manter regras de detecção de alta qualidade em um SOC

SOC_Process_Threat_Hunting_to_detection

Nível de Maturidade de Detecção

imagem As equipes de SOC se concentram em implementar detecções de alta fidelidade em todos os níveis da Pirâmide de Maturidade de Detecção, visando ameaças conhecidas com o mínimo de falsos positivos. O threat hunting complementa isso ao lidar com ameaças desconhecidas, TTPs avançados e anomalias propensas a altas taxas de falsos positivos, preenchendo lacunas e ampliando a cobertura de detecção além das capacidades padrão do SOC.

Checklist de Threat Hunting - Principais Áreas de Foco para Coleta de Inteligência

imagem

Exemplo de Metodologia de Threat Hunting Direcionada

imagem

Idealmente, cada sessão de threat hunting deve ter objetivos claros. Este fluxograma fornece uma abordagem estruturada para orientar seu processo, desde a preparação e investigação até recomendações acionáveis.

🎯 Lista de palavras-chave para sessões de ThreatHunting

Arquivos

Para a equipe azul (blueteam):

As listas ThreatHunting-Keywords podem ser valiosas para Threat Hunters, equipes de SOC e CERT para análise estática no SIEM, pois auxiliam na identificação de atores de ameaças (ou redteamers 😆) que utilizam configurações padrão de ferramentas de exploração conhecidas nos logs. Ela difere dos feeds de IoC por sua relevância duradoura: as palavras-chave aqui não têm 'datas de validade' e podem detectar ameaças anos após sua inclusão; são flexíveis, aceitando correspondências curinga e sem diferenciação de maiúsculas/minúsculas, e focadas apenas em palavras-chave padrão.

Projetada principalmente para Threat Hunting, esta lista pode ser útil em cenários complexos. Se você tem acesso a um SIEM que não gerencia, com dados não parseados, ou se faz parte de uma equipe de SOC com um SIEM bem gerenciado, os exemplos fornecidos aqui podem acelerar o processo de detecção de atividades maliciosas sem a necessidade de parsear nada. Se seus logs já são parseados, esta lista pode ser usada para corresponder campos em seus dados, potencialmente se transformando em uma regra de detecção com base na categoria de tipo de palavra-chave que você selecionar, desde que a taxa de falsos positivos seja suficientemente baixa.

⚠️ Nem tudo pode ser adicionado a esta lista; não fazemos detecções complexas de comportamento aqui, apenas detecções simples de palavras-chave em campos ou logs brutos, com o objetivo de detectar configurações padrão

⚠️ Muitas ferramentas na lista possuem regras de detecção dedicadas, correlacionando eventos com limites e relações de processos exclusivas... não cobriremos todas as detecções possíveis de uma ferramenta aqui, apenas detecções por palavras-chave

Se você faz parte de um Security Operations Center (SOC) e gerencia centenas de regras de detecção que dependem exclusivamente de detecções simples por palavras-chave, sem qualquer correlação de campos ou eventos, considere repensar sua abordagem. Na minha opinião, elas não deveriam constituir regras de detecção individuais. Em vez disso, elas podem ser mais adequadas a uma lista consolidada como esta, embora a implementação possa ser mais desafiadora se você não estiver usando uma plataforma como o Splunk.

Essa abordagem incentiva a criação de regras de alta qualidade e com propósito, mantendo suas detecções simples por palavras-chave em campos organizadas e gerenciáveis em um só lugar. O resultado final? Uma regra de detecção abrangente que cobre todas elas. Isso simplifica seu processo e otimiza suas capacidades de detecção.

Para respondedores a incidentes, você pode usar esta lista durante sua investigação em logs brutos ou arquivos para identificar rapidamente ferramentas de exploração conhecidas com as regras YARA Regras YARA, um script powershell ou ingerindo rapidamente seus logs no Splunk com Splunk4DFIR

Para a equipe vermelha (redteam):

Para evitar a detecção por simples correspondência de palavras-chave, é fundamental recompilar e renomear todas as strings personalizadas, nomes de classes ou funções, nomes de variáveis, nomes de argumentos, nomes de executáveis, user-agents padrão, certificados ou quaisquer outras strings que possam potencialmente ser associadas às ferramentas que você está usando durante sua operação. Empregue os nomes mais comuns para tudo, a fim de se misturar ao tráfego normal. Os scripts localizados aqui podem ajudá-lo a identificar alguns deles.

No entanto, se você estiver desenvolvendo 'ferramentas de red team' públicas, considere ajudar a equipe azul usando nomes distintos. Utilize uma configuração padrão com uma porta exótica, certificados personalizados, user-agents exclusivos, nomes e argumentos de funções específicos que não sejam comuns. Isso ajuda a criar uma assinatura clara que pode ser usada para detecções simples por palavras-chave, para que a equipe azul possa, pelo menos, detectar facilmente os script kiddies.

Conteúdo do Arquivo de Palavras-chave do Threat Hunting:

Cabeçalho: keyword,metadata_keyword_type,metadata_tool,metadata_description,metadata_tool_techniques,metadata_tool_tactics,metadata_malwares_name,metadata_groups_name,metadata_category,metadata_link,metadata_enable_endpoint_detection,metadata_enable_proxy_detection,metadata_tags,metadata_comment,metadata_severity_score,metadata_popularity_score,metadata_github_stars,metadata_github_forks,metadata_github_created_at,metadata_github_updated_at
keyword: As entradas nesta coluna representam palavras-chave que não diferenciam maiúsculas de minúsculas, usadas para Threat Hunting. Essas palavras-chave são flexíveis, permitindo o uso de curingas para ampliar ou restringir seus parâmetros de busca conforme necessário.
metadata_keyword_regex: As entradas nesta coluna representam o padrão de detecção regex para a palavra-chave; esses padrões são refinados para oferecer capacidades de detecção precisas, adequadas para uso com YARA, ripgrep ou ferramentas de detecção similares.
metadata_keyword_type: Tipo das palavras-chave. Atualmente, há três tipos:

Use a Lista para caçar com o Splunk:

faça o upload da lista threathunting-keywords.csv no Splunk
crie uma definição de lookup chamada threathunting-keywords para o lookup threathunting-keywords.csv
- nas opções avançadas, adicione o Match type WILDCARD(keyword) e certifique-se de que Case sensitive match não esteja marcado

transforms.conf``` [threathunting-keywords] batch_index_query = 0 case_sensitive_match = 0 filename = threathunting-keywords.csv match_type = WILDCARD(keyword)

- agora podemos usar nossa definição de lookup para caçar 🏹
> :warning: se as buscas da seção a seguir não parecerem funcionar, isso pode ser devido às configurações de limitação de recursos do Splunk, especialmente se você estiver executando o Splunk com a configuração padrão. Para começar, você pode ter que considerar aumentar o valor de `max_memtable_bytes` na seção `[lookup]`.

## Exemplos de casos de uso com `threathunting-keywords`:
![image](https://assets.kitploit.com/production/public/readmes/48741/204eb8e71d12257660c7166cb5f050747877e1968d7ff1f21812967d64355ca0.png)



### Caçar todas as palavras-chave nos logs brutos 😱```
`myendpointslogs` 
| lookup threathunting-keywords keyword as _raw OUTPUT keyword as keyword_detection metadata_keyword_type metadata_tool metadata_description metadata_tool_techniques metadata_tool_tactics metadata_malwares_name metadata_groups_name metadata_category	metadata_link	metadata_enable_endpoint_detection metadata_enable_proxy_detection metadata_comment
| search metadata_description!="" AND metadata_enable_endpoint_detection=1
| stats count earliest(_time) as firsttime latest(_time) as lasttime values(_raw) as raw by metadata_keyword_type keyword_detection index sourcetype 
| convert ctime(*time)

Envie o job para segundo plano e mantenha o ID do job.

myendpointslogs é uma macro que pesquisará todos os seus logs de endpoints, podendo ser logs do Windows, telemetria de EDR, sysmon, auditd, sessões de bastion, logs de execução do PowerShell ou qualquer outro log que monitore atividade de processos ou atividade de arquivos. (se você não usar macro, pode substituir a macro pelo seu index, tag ou datamodel)
- Incorporei intencionalmente uma macro nos exemplos para demonstrar que a exploração inicial pode ser feita com qualquer método que atenda às necessidades de cada um, seja um data model, tstats, tags, index/sourcetype. Embora o tstats combinado com um datamodel seja geralmente o caminho mais rápido, filtre com o comando TERM() para buscas específicas antes do |lookup, se necessário
| lookup isto é muito importante, para lookups grandes como este, use sempre |lookup em vez de |inputlookup. O |lookup usará o lookup enviado para os indexers quando o bundle for replicado, mas o |inputlookup enviará aos indexers a busca com todo o conteúdo do lookup a cada vez. Usando |lookup, ganhamos uma performance massiva aqui (esta busca será executada por horas em ambientes grandes, então é melhor otimizar nossa busca)
... keyword as _raw OUTPUT keyword as keyword_detection esta é a parte onde iremos corresponder o campo chamado com o campo em nosso lookup. No Splunk, é o log bruto sem qualquer parsing (nosso caso de uso). Quando uma keyword corresponde, o campo mostrará a keyword do lookup que correspondeu ao campo () aqui

Filtrar o resultado``` | loadjob 1684146257.1495958 | search NOT (keyword_detection IN ("fixme","fixme","fixme")) NOT (metadata_keyword_type IN ("fixme","fixme")) NOT (raw IN ("fixme","fixme","fixme"))

Exclua as palavras-chave obrigatórias, texto bruto ou tipos de palavras-chave.
se se decidir excluir o tipo `greyware tool keyword` (palavras-chave de ferramentas legítimas que são abusadas por atacantes) porque este ambiente tem demasiados resultados para este tipo de ferramentas, temos duas opções:

- Filtrar no início da nossa pesquisa inicial```
`myendpointslogs` 
| lookup threathunting-keywords keyword as _raw OUTPUT keyword as keyword_detection metadata_keyword_type metadata_tool metadata_description metadata_tool_techniques metadata_tool_tactics metadata_malwares_name metadata_groups_name metadata_category	metadata_link	metadata_enable_endpoint_detection metadata_enable_proxy_detection metadata_comment
| search metadata_description!="" metadata_keyword_type="offensive tool keyword" metadata_enable_endpoint_detection=1
| stats count earliest(_time) as firsttime latest(_time) as lasttime values(_raw) as raw by metadata_keyword_type keyword_detection index sourcetype 
| convert ctime(*time)

Eu adicionei um metadata_keyword_type="offensive tool keyword" para focar apenas em ferramentas ofensivas que tenho certeza que são usadas por atores maliciosos

Ou filtre após a nossa pesquisa inicial (para ganhar muito tempo):``` | loadjob 1684146257.1495958 | search metadata_keyword_type="offensive tool keyword"

Então esse era o nosso caso de uso para pesquisar em logs brutos nos logs de endpoint; se quisermos pesquisar as palavras-chave para logs de rede (qualquer coisa que possa registrar uma consulta ou uma URL), simplesmente mudamos para:```
`mynetworklogs` 
| lookup threathunting-keywords keyword as _raw OUTPUT keyword as keyword_detection metadata_keyword_type metadata_tool metadata_description metadata_tool_techniques metadata_tool_tactics metadata_malwares_name metadata_groups_name metadata_category	metadata_link	metadata_enable_endpoint_detection metadata_enable_proxy_detection metadata_comment
| search metadata_description!="" AND metadata_enable_proxy_detection=1
| stats count earliest(_time) as firsttime latest(_time) as lasttime values(_raw) as raw by metadata_keyword_type keyword_detection index sourcetype 
| convert ctime(*time)

Agora é o mesmo que a primeira busca, mas eu mudei a fonte de dados para mynetworklogs e adicionei metadata_enable_proxy_detection=1 para corresponder às palavras-chave relevantes para registros de rede (é melhor ter logs de proxy e DNS para isso)

Caça às palavras-chave em outros campos 🙂 (url,process,commandline,query...):

Corresponder apenas no campo url:```

mynetworklogs url=* | lookup threathunting-keywords keyword as url OUTPUT keyword as keyword_detection metadata_keyword_type metadata_tool metadata_description metadata_tool_techniques metadata_tool_tactics metadata_malwares_name metadata_groups_name metadata_category metadata_link metadata_enable_endpoint_detection metadata_enable_proxy_detection metadata_comment | search metadata_description!="" AND metadata_enable_proxy_detection=1 | stats count earliest(_time) as firsttime latest(_time) as lasttime values(url) as url by src_ip metadata_keyword_type keyword_detection index sourcetype | convert ctime(*time)

#### Corresponder apenas no campo de consulta:```
`mynetworklogs` query=*
| lookup threathunting-keywords keyword as query OUTPUT keyword as keyword_detection metadata_keyword_type metadata_tool metadata_description metadata_tool_techniques metadata_tool_tactics metadata_malwares_name metadata_groups_name metadata_category	metadata_link	metadata_enable_endpoint_detection metadata_enable_proxy_detection metadata_comment
| search metadata_description!="" AND metadata_enable_proxy_detection=1
| stats count earliest(_time) as firsttime latest(_time) as lasttime values(query) as query by src_ip metadata_keyword_type keyword_detection index sourcetype 
| convert ctime(*time)

Correspondência em vários campos ao mesmo tempo, exemplo para logs de endpoint:```

myendpointslogs | eval myfields=mvappend(service, process, process_command, parent_process, parent_process_command, grand_parent_process, grand_parent_process_command, file_path, file_name) | lookup threathunting-keywords keyword as myfields OUTPUT keyword as keyword_detection metadata_keyword_type metadata_tool metadata_description metadata_tool_techniques metadata_tool_tactics metadata_malwares_name metadata_groups_name metadata_category metadata_link metadata_enable_endpoint_detection metadata_enable_proxy_detection metadata_comment | search metadata_description!="" AND metadata_enable_endpoint_detection=1 | stats count earliest(_time) as firsttime latest(_time) as lasttime values(process) values(service) values(process_command) values(file_name) values(file_path) values(parent_process) values(parent_process_command) values(grand_parent_process) values(grand_parent_process_command) by metadata_keyword_type keyword_detection index sourcetype | convert ctime(*time)

#### Velocidade:

Se a velocidade for uma preocupação ou se você estiver planejando implementar isso como uma regra de detecção agendada, talvez queira considerar dividir a pesquisa em pesquisas diferentes escolhendo a coluna metadata_keyword_type ou metadata_tool que deseja usar.

Observe que filtrar usando o comando search após `|lookup` não agiliza o processo de busca. Se você quiser se concentrar em uma parte específica da pesquisa sem dividi-la, use o comando `|inputlookup` junto com a cláusula where. Embora esse método possa consumir mais recursos de CPU, geralmente resulta em uma execução mais rápida. Para mais detalhes, consulte a documentação do Splunk sobre inputlookup: https://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Inputlookup

#### Com ELK:

Se você estiver trabalhando com o Elastic Stack, há muitas restrições para listas (você não pode usar caracteres especiais, espaços ...), você tem 3 opções:
- Use outra lista disponível aqui no mesmo repositório https://github.com/mthcht/ThreatHunting-Keywords/tree/main/elk (não é uma extração direta de threathunting-keywords.csv, é modificada para ELK e não atualizada)
- Use regras Sigma de "caça", extraídas diretamente deste projeto https://github.com/mthcht/ThreatHunting-Keywords-sigma-rules com pysigma para a conversão
- Use algumas das minhas listas como uma lista de IOCs com consultas wildcard https://www.elastic.co/guide/en/elasticsearch/reference/8.15/query-dsl-wildcard-query.html#wildcard-top-level-params
 
### Exemplo de Dashboard
![image](https://assets.kitploit.com/production/public/readmes/48741/df177e7f2584b823c311a2b223eed8b237d8a72c05d0afb9d6b6f350e42ccda0.png)

### Splunk4DFIR
Outro exemplo de uso dos arquivos csv do projeto com splunk para caçar em artefatos e logs de DFIR: https://github.com/mf1d3l/Splunk4DFIR
![image](https://assets.kitploit.com/production/public/readmes/48741/73d54c5b146c34685ebac4ed7ed2a9da11a3f90e6ae9ac0a4b17118d7895cbe3.png)

### Outras listas incríveis para detecção
Eu mantenho alguns artefatos relevantes em listas separadas; essas listas são mais precisas e podem ser usadas em regras de detecção. Elas estão disponíveis neste [repositório do github](https://github.com/mthcht/awesome-lists/tree/main/Lists)
você encontrará:

Minha planilha de coleta de inteligência para planejar sessões de Threat Hunting

![folha de coleta de inteligência](https://assets.kitploit.com/production/public/readmes/48741/498b188eaebabe5a7077300eeff16daee903ed30d0b1797b82c208a54ba1424d.png)


- 📋 Listas: https://github.com/mthcht/awesome-lists/tree/main/Lists
- 🕵️‍♂️ Guias de ThreatHunting: https://mthcht.medium.com/list/threat-hunting-708624e9266f
- 🚰 Named pipes suspeitos: [suspicious_named_pipe_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_named_pipe_list.csv)
- 🌐 TLDs suspeitos (atualizados automaticamente): [[suspicious_TLDs]](https://github.com/mthcht/awesome-lists/tree/main/Lists/TLDs)
- 🌐 ASNs suspeitos (atualizados automaticamente): [[suspicious ASNs]](https://github.com/mthcht/awesome-lists/tree/main/Lists/ASNs)
- 🔧 Serviços do Windows suspeitos: [suspicious_windows_services_names_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_windows_services_names_list.csv)
- ⏲️ Tarefas do Windows suspeitas: [suspicious_windows_tasks_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_windows_tasks_list.csv)
- 🚪 Porta de destino suspeita: [suspicious_ports_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_ports_list.csv)
- 🛡️ Regras de Firewall suspeitas: [suspicious_windows_firewall_rules_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_windows_firewall_rules_list.csv)
- 🆔 User-agent suspeito: [suspicious_http_user_agents_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_http_user_agents_list.csv)
- 📇 IDs USB suspeitos: [suspicious_usb_ids_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_usb_ids_list.csv)
- 🔢 Endereço MAC suspeito: [suspicious_mac_address_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_mac_address_list.csv)
- 📛 Hostname suspeito: [suspicious_hostnames_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_hostnames_list.csv)
- 🧮 Metadados de Executáveis: [executables_metadata_informations_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/Windows%20Metadata/executables_metadata_informations_list.csv)
- 🕸️ Lista de servidores DNS over HTTPS: [dns_over_https_servers_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/dns_over_https_servers_list.csv)
- 📚 Hijacklibs (atualizados automaticamente): [hijacklibs_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/Hijacklibs/hijacklibs_list.csv)
- 🌐 Listas de Nós TOR (atualizadas automaticamente): https://github.com/mthcht/awesome-lists/tree/main/Lists/TOR
- 🛠️ Lista LOLDriver (atualizada automaticamente): [loldrivers_only_hashes_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/Drivers/loldrivers_only_hashes_list.csv)
- 🛠️ Lista de Bootloaders Maliciosos (atualizada automaticamente): [malicious_bootloaders_only_hashes_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/Drivers/malicious_bootloaders_only_hashes_list.csv)
- 📜 Lista de Certificados SSL Maliciosos (atualizada automaticamente): [ssl_certificates_malicious_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/SSL%20CERTS/ssl_certificates_malicious_list.csv)
- 🖥️ Detecção de RMM: https://github.com/mthcht/awesome-lists/tree/main/Lists/RMM
- 👤🔑 Funções e grupos importantes para AD/EntraID/AWS: [[permissions]](https://github.com/mthcht/awesome-lists/tree/main/Lists/permissions)
- 💻🔒 Extensões de arquivo conhecidas de ransomware: [ransomware_extensions_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/ransomware_extensions_list.csv)
- 💻🔒 Nomes de arquivo conhecidos de notas de resgate de ransomware: [ransomware_notes_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/ransomware_notes_list.csv)
- 📝 Regras ASR do Windows: [windows_asr_rules.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/windows_asr_rules.csv)
- 🌐 Listas DNSTWIST (atualizadas automaticamente): [Domínios Padrão DNSTWIST + script](https://github.com/mthcht/awesome-lists/tree/main/Lists/DNSTWIST)
- 🌍 Listas de endereços IP de VPN (atualizadas automaticamente): 
  - 🛡️ NordVPN: [nordvpn_ips_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/VPN/NordVPN/nordvpn_ips_list.csv)
  - 🛡️ ProtonVPN: [protonvpn_ip_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/VPN/ProtonVPN/protonvpn_ip_list.csv)
- 🏢 Listas de Faixas de IP de Empresas (atualizadas automaticamente): [Listas Padrão + script](https://github.com/mthcht/awesome-lists/tree/main/Lists/Ranges_IP_Address_Company_List/bgp.he.net)
- 🔗 Outras listas de correlação: https://github.com/mthcht/awesome-lists/tree/main/Lists/Others
- 📋 Listas que preciso terminar: https://github.com/mthcht/awesome-lists/tree/main/todo


Confira estes [Guias](https://github.com/mthcht/awesome-lists/tree/main/Lists#how-to-use-the-lists) para usar algumas das listas: 
  - [Pesquisas de Serviços do Windows](https://detect.fyi/threat-hunting-suspicious-windows-service-names-2f0dceea204c)
  - [Pesquisas de User-Agents](https://mthcht.medium.com/threat-hunting-suspicious-user-agents-3dd764470bd0)
  - [Pesquisas de DNS Over HTTPS](https://mthcht.medium.com/detecting-dns-over-https-30fddb55ac78)
  - [Pesquisas de TLDs Suspeitos](https://mthcht.medium.com/threat-hunting-suspicious-tlds-a742c2adbf58)
  - [Pesquisas de HijackLibs](https://mthcht.medium.com/detect-dll-hijacking-techniques-from-hijacklibs-with-splunk-c760d2e0656f)
  - [Pesquisas de Phishing e DNSTWIST](https://detect.fyi/detecting-phishing-attempts-with-dnstwist-37c426b3bbb8)
  - [Pesquisas de extensões de navegadores](https://mthcht.medium.com/detecting-browser-extensions-installations-e0ac2b45c46b)
  - [C2 se escondendo à vista](https://mthcht.medium.com/c2-hiding-in-plain-sight-7a83963b9344)
  - [Artefatos de HTML Smuggling](https://mthcht.medium.com/detecting-html-smuggling-phishing-attempts-15af824e60e4)
  - [Pesquisas de PSEXEC e ferramentas semelhantes](https://mthcht.medium.com/detecting-psexec-and-similar-tools-c812bf3dca6c)
  - [Detecção de Time Slipping](https://mthcht.medium.com/event-log-manipulations-1-time-slipping-55bf95631c40)
  - [Named pipes suspeitos](https://medium.com/detect-fyi/threat-hunting-suspicious-named-pipes-a4206e8a4bc8)
 
... mais [aqui](https://github.com/mthcht/awesome-lists/tree/main/Lists#how-to-use-the-lists) 

## Busca DFIR por palavras-chave em arquivos (Sem SIEM)
Após conduzir uma revisão minuciosa de várias ferramentas, descobri que o [ripgrep](https://github.com/BurntSushi/ripgrep) supera significativamente seus concorrentes quando se trata de corresponder rapidamente uma extensa lista de padrões regex em cada linha de um arquivo de log grande ou até mesmo em vários arquivos simultaneamente. Ele se mostrou a solução mais eficiente para lidar com grandes volumes de dados, proporcionando velocidade e flexibilidade incomparáveis.

### Procure por malwares em arquivos de log com **Ripgrep** e a lista 'only_keywords_regex.txt'
#### `rg.exe -f .\only_keywords_regex.txt .\EvtxECmd_Output.csv --multiline --ignore-case`
- .\only_keywords_regex.txt serve como arquivo de origem das palavras-chave de threat hunting, transformadas em padrões regex para correspondência precisa. Esses padrões são originados do arquivo threathunting-keywords.csv, que passou por um processo de conversão para otimizar a compatibilidade com operações regex.
- .\EvtxECmd_Output.csv representa o arquivo de destino no qual a pesquisa será conduzida. Nesse contexto, é um formato .csv de um log de eventos do Windows, produzido pela exportação de logs evtx. No entanto, a flexibilidade do ripgrep permite substituí-lo por qualquer arquivo de sua escolha para operações detalhadas de busca de padrões.
- A opção --multiline permite que o ripgrep lide e corresponda efetivamente a padrões que se estendem por várias linhas, ampliando significativamente o escopo da pesquisa.
Você obterá as linhas correspondentes assim, com o número da linha (mas sem a palavra-chave correspondente)

![image](https://assets.kitploit.com/production/public/readmes/48741/d205ae3caf99906a03818c202e8811b669948e2f68b88cc137cba8cf0e43b69f.png)

![image](https://assets.kitploit.com/production/public/readmes/48741/e1b213fc63e1ec2914e0f1eb3263d17aa960eb50672fd18986a0f75d50e9c379.png)

#### Opção melhor para arquivos muito grandes (no Windows):
[DFIR_hunt_in_file.ps1](https://github.com/mthcht/ThreatHunting-Keywords/blob/main/DFIR_hunt_in_file.ps1)

`powershell -ep Bypass -File .\DFIR_hunt_in_file.ps1 -patternFile "only_keywords_regex.txt" -targetFile "C:\Users\mthcht\collection\20230406154410_EvtxECmd_Output.csv" -rgPath "C:\Users\mthcht\Downloads\ripgrep-13.0.0-x86_64-pc-windows-msvc\ripgrep-13.0.0-x86_64-pc-windows-msvc\rg.exe"`
- `-targetFile`: especifica o arquivo a ser pesquisado (no exemplo, um log extraído do DFIR-ORC)
- `-patternFile`: o arquivo contendo os padrões regex `only_keywords_regex.txt`
- `-rgPath`: o caminho do executável ripgrep

conteúdo do script powershell (incluído no repositório):```powershell
param (
    [Parameter(Mandatory=$true)]
    [string]$patternFile,
    [Parameter(Mandatory=$true)]
    [string]$targetFile,
    [Parameter(Mandatory=$true)]
    [string]$rgPath
)

Start-Transcript -Path "$PSScriptRoot\result_search.log" -Append -Force -Verbose

$totalLines = (Get-Content $patternFile | Measure-Object -Line).Lines
$currentLine = 0
Get-Content $patternFile | ForEach-Object {
    $currentLine++
    Write-Host "Searching for pattern $currentLine of $totalLines : $_"  
    & $rgPath --multiline --ignore-case $_ $targetFile | Write-Output 
}

Stop-Transcript -Verbose

O resultado da pesquisa estará em result_search.log no mesmo diretório do script.

Melhor opção para arquivos muito grandes (no linux):

todo

Caça ao mal em arquivo apenas com powershell e a lista 'only_keywords.txt ' (mais lento não recomendado)

No powershell é muito mais lento, mas se você ainda quiser fazer dessa forma, pode usar o script abaixo; ele informará o número da linha em que houve correspondência e a palavra-chave correspondente:

powershell.exe -ep Bypass -File .\hunt_keywords_windows.ps1 -k .\only_keywords.txt -f .\EvtxECmd_Output.csv

```powershell param( [Parameter(Mandatory=$true)] [string]$file,

[Parameter(Mandatory=$true)]
[string]$kw

)

$Keywords = Get-Content $kw $result = @()

foreach ($Keyword in $Keywords) { $SearchTerm = $Keyword.Replace("", ".") $SearchTerm = [Regex]::Escape($SearchTerm).Replace(".*", ".*")

$reader = New-Object System.IO.StreamReader($file)
$lineNumber = 0
while (($line = $reader.ReadLine()) -ne $null) {
    $lineNumber++
    if ($line -match $SearchTerm) {
        $result += New-Object PSObject -Property @{
            'Keyword' = $Keyword
            'LineNumber' = $lineNumber
            'Line' = $line
        }
    }
}
$reader.Close()

}

$result | Out-GridView Read-Host -Prompt "Press Enter to exit"

</details>

### Regras YARA
![image](https://assets.kitploit.com/production/public/readmes/48741/e1355c1b331e4e617189507532d5fc1045ae7eb085259c2e6a3c51338b88fcf2.png)

Todos os padrões de detecção deste projeto são automaticamente exportados para regras yara em [ThreatHunting-Keywords-yara-rules](https://github.com/mthcht/ThreatHunting-Keywords-yara-rules)

Alguns exemplos de caça com as regras yara:
![2023-10-20 20_23_59-(1) mthcht on X_ _The #ThreatHunting Keywords project is slowly progressing, alm](https://assets.kitploit.com/production/public/readmes/48741/be09b835bf23d364e39cd4538a510d9f6f8d249396b3e8440cb1ce6e5f63ce82.png)
 
![2023-10-20 20_14_17-C__Users_Public_Pictures](https://assets.kitploit.com/production/public/readmes/48741/ad815de74d8983987eb38e1a7e63f1540216ff50163da319e82e0219c01dbd5a.png)

![2023-10-21 11_14_15-Editing ThreatHunting-Keywords-yara-rules_README md at main · mthcht_ThreatHunti](https://assets.kitploit.com/production/public/readmes/48741/6fa65b15d788cfe2790498294078225e7f4c004c193b69ed56acfca51ba6829c.png)
![2023-10-21 11_12_44-](https://assets.kitploit.com/production/public/readmes/48741/8b235e92d44bf445d7f47edd27b161a0d6cfbd58e5158386993541d53da31942.png)

## Tabela de dados rápida para pesquisa de palavras-chave
https://mthcht.github.io/ThreatHunting-Keywords/
![image](https://assets.kitploit.com/production/public/readmes/48741/477608f39dee047778948ef170316f7d59e2fb0e2437b53e39e7de6900ecb900.png)

## Falsos positivos

Contribua e adicione seus falsos positivos à [lista](https://github.com/mthcht/ThreatHunting-Keywords/blob/main/_false_positives/false_positives_offensive_keywords.md) de falsos positivos esperados

## Regras SIGMA

Confira a lookup traduzida em [regras SIGMA](https://github.com/mthcht/ThreatHunting-Keywords-sigma-rules) normalmente atualizo ao mesmo tempo :)

![image](https://assets.kitploit.com/production/public/readmes/48741/298b4f42a0702b8a14376577a5fc2c670aa7a8246f9ee41cad9b39d573df0432.png)

## Mapeamento de técnicas MITRE ATT&CK

com o add-on do Splunk https://splunkbase.splunk.com/app/5742
![image](https://assets.kitploit.com/production/public/readmes/48741/6605c5297f2d2536e18f593e2a3f5ec02ed5e66adbe4970247a3eccba0cbe31d.png)

Cobertura para 2242 ferramentas (atualizado em 2024/08/30):
![image](https://assets.kitploit.com/production/public/readmes/48741/eafcd79072b45d2a583d286d9d03084c01dba1de233c7b77f208f6c379081d84.png)


busca do Splunk:

<details>```
| inputlookup threathunting-keywords.csv
| stats count by metadata_tool metadata_tool_techniques
| makemv delim=" - " metadata_tool_techniques
| mvexpand metadata_tool_techniques
| stats count by metadata_tool_techniques

Matriz de ferramentas

Dashboards do Splunk (este é apenas um exemplo; uma grande variedade de filtros pode ser aplicada usando os campos disponíveis no arquivo):

Grupos de Atores de Ameaças por ferramentas neste projeto

exemplo de dashboard xml do splunk:

``` tools matrix tools_matrix tool categories metadata_category metadata_category | inputlookup threathunting-keywords.csv | stats count by metadata_category | fields - count -24h@h now all metadata_category IN ( ) * " " , groups name ALL metadata_groups_name IN ( ) * " " , metadata_groups_name metadata_groups_name | inputlookup threathunting-keywords.csv | stats count by metadata_groups_name | fields - count | eval metadata_groups_name = split(metadata_groups_name, " - ") | mvexpand metadata_groups_name | dedup metadata_groups_name -24h@h now | inputlookup threathunting-keywords.csv | search metadata_groups_name!=N/A $category$ | stats count as detection_patterns by metadata_groups_name metadata_tool | eval metadata_groups_name = split(metadata_groups_name, " - ") | mvexpand metadata_groups_name | search $groups$ -24h@h now none 728 progressbar categorical #3fc77a #d93f3c 6 false true true false true false true ```

🤝 Contribuindo

Contribuições, problemas e pedidos de recursos são bem-vindos!

Se você quiser que eu adicione uma ferramenta à lista, crie uma issue com este modelo:

Nome da Ferramenta:

``

Forneça o nome da ferramenta.

Site Oficial ou Link do Código-Fonte:

``

Forneça um link para o site oficial da ferramenta ou repositório de código-fonte (GitHub, GitLab, etc.). Se houver documentação disponível, inclua-a.

Descrição da Ferramenta:

``

Descreva o propósito, a funcionalidade e os recursos notáveis da ferramenta. Se não tiver certeza, deixe em branco e eu revisarei a ferramenta em mais detalhes.

Uso Conhecido por Atores Maliciosos (se aplicável):

``

Se você tiver informações sobre uso indevido conhecido ou potencial desta ferramenta por atores maliciosos, compartilhe-as aqui.

Classificação da Ferramenta:

Escolha a categoria mais apropriada para a ferramenta:

Ofensiva (Usada principalmente por atacantes, não legítima para uso geral)
Greyware (Ferramenta legítima que costuma ser abusada por atores maliciosos)
Assinaturas/Palavras-chave Genéricas (Assinaturas ou termos comuns associados a malware, conforme detectados por produtos de segurança)

Proponha alterações à lista com um PR (forneça feedbacks de falsos positivos, amostra de logs se possível), se uma palavra-chave estiver gerando muitos falsos positivos em muitos ambientes, podemos excluí-la)

Decidirei se vale a pena adicionar uma ferramenta à lista. Ferramentas amplamente usadas e reconhecidas pela comunidade têm mais chances de serem incluídas do que ferramentas obscuras ou novas.

ThreatHunting-Keywords

Mais Populares

ThreatHunting-Keywords

Índice

O que é Threat Hunting ?

Vantagens do Threat Hunting:

Integrando o Threat Hunting aos Serviços Principais

Ciclo de Vida do Threat Hunting nas Operações de SOC

Nível de Maturidade de Detecção

Checklist de Threat Hunting - Principais Áreas de Foco para Coleta de Inteligência

Exemplo de Metodologia de Threat Hunting Direcionada

Arquivos

Para a equipe azul (blueteam):

Para a equipe vermelha (redteam):

Conteúdo do Arquivo de Palavras-chave do Threat Hunting:

Use a Lista para caçar com o Splunk:

Caça às palavras-chave em outros campos 🙂 (url,process,commandline,query...):

Corresponder apenas no campo url:```

Correspondência em vários campos ao mesmo tempo, exemplo para logs de endpoint:```

Melhor opção para arquivos muito grandes (no linux):

Caça ao mal em arquivo apenas com powershell e a lista 'only_keywords.txt ' (mais lento não recomendado)

Matriz de ferramentas

Grupos de Atores de Ameaças por ferramentas neste projeto

🤝 Contribuindo

Se você quiser que eu adicione uma ferramenta à lista, crie uma issue com este modelo:

Nome da Ferramenta:

Site Oficial ou Link do Código-Fonte:

Descrição da Ferramenta:

Uso Conhecido por Atores Maliciosos (se aplicável):

Classificação da Ferramenta:

Proponha alterações à lista com um PR (forneça feedbacks de falsos positivos, amostra de logs se possível), se uma palavra-chave estiver gerando muitos falsos positivos em muitos ambientes, podemos excluí-la)