
Lista impresionante de palabras clave y artefactos para sesiones de Threat Hunting
🎯 Lista de palabras clave para sesiones de ThreatHunting


La caza de amenazas (threat hunting) es un enfoque proactivo e iterativo para detectar actividades maliciosas dentro de la red o los sistemas de una organización que puedan haber evadido las medidas de seguridad automatizadas. A diferencia de las investigaciones reactivas desencadenadas por alertas de seguridad, la caza de amenazas se impulsa mediante comprobaciones basadas en inteligencia de amenazas (TI por sus siglas en inglés) y en hipótesis derivadas de un análisis sistemático y oportunista. Estas hipótesis 💡 ayudan a los cazadores a descubrir amenazas desconocidas, amenazas potenciales o amenazas conocidas que hayan podido evadir las detecciones de seguridad, así como vulnerabilidades o indicadores de compromiso (IoCs) que los sistemas automatizados podrían pasar por alto o excluir. El proceso también se centra en identificar precursores de alertas/dashboards y en mejorar los flujos de trabajo del SOC y del triaje, al tiempo que contribuye a la gestión del inventario de activos fantasma (shadow assets) y escala eventos de fidelidad baja/media que requieren una investigación adicional. El objetivo principal es identificar las tácticas, técnicas y procedimientos (TTPs) utilizados por los actores de amenazas, mejorando la capacidad de la organización para detectar y mitigar proactivamente posibles ataques.

Mi sugerencia de proceso para organizar sesiones de threat hunting parcialmente automatizadas y mantener reglas de detección de alta calidad dentro de un SOC


Los equipos del SOC se centran en implementar detecciones de alta fidelidad en todos los niveles de la Pirámide de Madurez de Detección, apuntando a amenazas conocidas con mínimos falsos positivos. El threat hunting complementa esto abordando amenazas desconocidas, TTPs avanzados y anomalías propensas a altas tasas de falsos positivos, cubriendo brechas y mejorando la cobertura de detección más allá de las capacidades estándar del SOC.


Idealmente, cada sesión de threat hunting debería tener objetivos claros. Este diagrama de flujo proporciona un enfoque estructurado para guiar tu proceso, desde la preparación y la investigación hasta recomendaciones accionables.
🎯 Lista de palabras clave para sesiones de ThreatHunting
Las listas de ThreatHunting-Keywords pueden ser valiosas para los Threat Hunters, los equipos SOC y CERT para análisis estático en SIEM, ya que ayudan a identificar actores de amenazas (o redteamers 😆) que utilizan configuraciones predeterminadas de herramientas de explotación reconocidas en los logs. Se diferencia de los feeds de IoC por su relevancia perdurable: los keywords aquí no tienen 'fechas de caducidad' y pueden detectar amenazas años después de su inclusión; son flexibles, aceptan comodines y coincidencias sin distinción de mayúsculas/minúsculas, y se centran únicamente en keywords predeterminados.
Diseñada principalmente para Threat Hunting, esta lista puede ser útil en escenarios complejos. Ya sea que tengas acceso a un SIEM que no administras, con datos sin parsear, o que formes parte de un equipo SOC con un SIEM bien gestionado, los ejemplos proporcionados aquí pueden acelerar el proceso de detección de actividad maliciosa sin necesidad de parsear nada. Si tus logs ya están parseados, esta lista se puede usar para hacer coincidir campos dentro de tus datos, convirtiéndose potencialmente en una regla de detección según la categoría de tipo de keyword que selecciones, siempre que la tasa de falsos positivos sea suficientemente baja.
⚠️ No todo puede añadirse en esta lista; no hacemos detecciones complejas de comportamiento aquí, solo detecciones simples de keywords en campos o logs sin procesar, destinadas a detectar configuraciones predeterminadas
⚠️ Muchas herramientas de la lista tienen reglas de detección dedicadas, correlacionando eventos con umbrales y relaciones de proceso únicas... no cubriremos todas las detecciones posibles para una herramienta aquí, solo detecciones de keywords
Si formas parte de un Centro de Operaciones de Seguridad (SOC) y gestionas cientos de reglas de detección que dependen únicamente de detecciones simples de keywords sin correlación de campos o eventos, considera replantear tu enfoque. En mi opinión, estas no deberían constituir reglas de detección individuales. En su lugar, podrían adaptarse mejor a una lista consolidada como esta, aunque la implementación podría ser más desafiante si no usas una plataforma como Splunk.
Este enfoque fomenta la creación de reglas de alta calidad y con propósito, manteniendo tus detecciones simples de keywords en campos organizadas y manejables en un solo lugar. ¿El resultado final? Una regla de detección integral que las cubre todas. Esto agiliza tu proceso y optimiza tus capacidades de detección.
Para los respondedores de incidentes, puedes usar esta lista durante tu investigación en logs sin procesar o archivos para identificar rápidamente herramientas de explotación conocidas con las reglas YARA Reglas YARA, un script de Powershell o ingiriendo rápidamente tus logs en Splunk con Splunk4DFIR
Para evadir la detección por detección simple de keywords, es fundamental recompilar y renombrar todas las cadenas personalizadas, nombres de clases o funciones, nombres de variables, nombres de argumentos, nombres de ejecutables, user-agents predeterminados, certificados o cualquier otra cadena que pueda asociarse potencialmente con las herramientas que estés utilizando durante tu operación. Emplea los nombres más comunes para todo, a fin de mezclarte con el tráfico normal. Los scripts ubicados aquí pueden ayudarte a identificar algunos de estos.
Sin embargo, si estás desarrollando "herramientas de red team" públicas, considera ayudar al equipo azul utilizando nombres distintivos. Emplea una configuración predeterminada con un puerto exótico, certificados personalizados, user-agents únicos, nombres de funciones y argumentos específicos que no sean comunes. Esto ayuda a crear una firma clara que pueda usarse para detecciones simples de keywords, de modo que el equipo azul pueda al menos detectar fácilmente a los script kiddies.
Encabezado: 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: Las entradas en esta columna representan keywords no sensibles a mayúsculas utilizados para Threat Hunting. Estos keywords son flexibles y permiten el uso de comodines para ampliar o reducir tus parámetros de búsqueda según sea necesario.
metadata_keyword_regex: Las entradas en esta columna representan la detección mediante patrón regex del keyword; estos patrones están refinados para ofrecer capacidades de detección precisas, adecuadas para su uso con YARA, ripgrep o herramientas de detección similares.
metadata_keyword_type: Tipo de los keywords. Actualmente hay tres tipos:
offensive tool keyword: Estos keywords se relacionan con herramientas ofensivas o muestran una alta confianza de intención maliciosa. Es crucial que estos términos sean relevantes y fiables para detectar posibles amenazas (baja tasa de falsos positivos)greyware tool keyword: Los keywords en esta categoría corresponden a herramientas 'legítimas' que son abusadas por actores maliciosos. Dado que estas herramientas también tienen usos legítimos, el potencial de falsos positivos es inherentemente mayor. Es importante interpretar estos resultados con la comprensión de que no todas las detecciones pueden significar actividad maliciosa.signature keyword: Estos keywords pueden no asociarse directamente con herramientas, pero pueden incluir nombres de firmas de productos de seguridad, cadenas específicas o palabras significativas en la detección de amenazas.metadata_tool: Nombre de la herramienta que queremos detectar
metadata_description: descripción de la herramienta que queremos detectar
metadata_tool_techniques: técnicas MITRE relacionadas con la herramienta que queremos detectar
metadata_tool_tactics: tácticas MITRE relacionadas con la herramienta que queremos detectar
metadata_malwares_name: nombres de variantes de malware que utilizan la herramienta en cuestión
metadata_groups_name: nombres de los grupos de actores de amenazas asociados con la herramienta
metadata_category: nombre de la categoría global de la herramienta. Esto puede cambiar más adelante y las sugerencias son bienvenidas.
metadata_link: enlace a la herramienta (código fuente, artículos, muestras, blog ...)
metadata_enable_endpoint_detection: Campo que indica si el keyword puede emplearse eficazmente en búsquedas en logs de endpoint. Esto incluye, entre otros, registros de eventos de Windows, EDR, logs de PowerShell, auditd, sesiones bastión, Sysmon o cualquier fuente de datos que contenga campos de actividad de procesos y archivos.
metadata_enable_proxy_detection: Campo que indica la aplicabilidad del keyword para búsquedas dentro de logs de red (Proxy, logs DNS o cualquier dato con consultas y URL originadas desde la red interna)
metadata_popularity_score: puntuación del 1 al 10 (de baja a alta popularidad)
metadata_severity_score: puntuación del 1 al 10 (de baja a alta severidad)
metadata_tags: etiquetas para identificar artefactos específicos; varias etiquetas pueden estar asociadas a un keyword. Cuando algunos de los artefactos específicos no pueden añadirse a las listas sin más contexto de detección, se añaden en otras listas increíbles para_detección
metadata_comment: Este campo puede contener un comentario útil añadido para el keyword.
metadata_github_stars: Número de estrellas en el proyecto de GitHub (si la herramienta está en GitHub; si está en otro lugar, el valor es N/A). Esto se usa para calcular la puntuación de popularidad.
metadata_github_forks: Número de forks en el proyecto de GitHub (si la herramienta está en GitHub; si está en otro lugar, el valor es N/A). Puede usarse para estadísticas de dashboard de las herramientas más utilizadas.
metadata_github_created_at: Fecha de creación del proyecto de GitHub (si la herramienta está en GitHub; si está en otro lugar, el valor es N/A). Puede usarse para estadísticas de dashboard.
metadata_github_updated_at: Fecha de última actualización del proyecto de GitHub (si la herramienta está en GitHub; si está en otro lugar, el valor es N/A). Puede usarse para rastrear actualizaciones importantes de herramientas ofensivas y ajustar las detecciones de keywords.
sube la lista threathunting-keywords.csv a Splunk
crea una definición de lookup llamada threathunting-keywords para el lookup threathunting-keywords.csv
WILDCARD(keyword) y asegúrate de que Case sensitive match no esté marcado
transforms.conf``` [threathunting-keywords] batch_index_query = 0 case_sensitive_match = 0 filename = threathunting-keywords.csv match_type = WILDCARD(keyword)
- ahora podemos usar nuestra definición de lookup para cazar 🏹
- :warning: si las búsquedas de las siguientes secciones no parecen funcionar, puede deberse a los límites de recursos de Splunk, especialmente si estás ejecutando Splunk con la configuración predeterminada. Para empezar, puedes considerar aumentar el valor de `max_memtable_bytes` en el bloque `[lookup]`.
## Ejemplos de casos de uso con `threathunting-keywords`:

### Cazar todas las palabras clave en los registros sin procesar 😱```
`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)
Envía el trabajo a segundo plano y conserva el ID del trabajo.

myendpointslogs es una macro que buscará en todos los registros de tus endpoints; pueden ser registros de Windows, telemetría EDR, sysmon, auditd, sesiones de bastion, registros de ejecución de PowerShell o cualquier otro registro que supervise la actividad de procesos o de archivos. (si no usas la macro, puedes reemplazarla por tu índice, etiqueta o datamodel)
TERM() para búsquedas específicas antes del |lookup si es necesario| lookup esto es muy importante; para lookups grandes como este, usa siempre |lookup en lugar de |inputlookup. |lookup utilizará la lookup distribuida a los indexadores cuando el bundle se replica, pero |inputlookup enviará a los indexadores la búsqueda con todo el contenido de la lookup cada vez. Al usar |lookup ganamos mucho rendimiento aquí (esta búsqueda se ejecutará durante horas en entornos grandes, así que es mejor optimizarla).... keyword as _raw OUTPUT keyword as keyword_detection esta es la parte donde compararemos el campo llamado _raw con el campo keyword en nuestra lookup; en Splunk, _raw es el registro sin procesar (nuestro caso de uso). Cuando una keyword coincide, el campo keyword_detection mostrará la keyword de la lookup que coincidió con el campo (_raw) aquí.| search metadata_description!="" AND metadata_enable_endpoint_detection=1 aquí nos centramos solo en los registros de endpoints, por lo que añadimos metadata_enable_endpoint_detection=1 para que coincida únicamente con las keywords relevantes para registros de endpoints y metadata_description!="" para tener solo las keywords coincidentes.| stats count earliest(_time) as firsttime latest(_time) as lasttime values(_raw) as raw by metadata_keyword_type keyword_detection index sourcetype aquí hice un filtro rápido sin todos los campos de la lookup para el ejemplo (pero también puedes añadirlos si quieres tener más posibilidades de exclusión); esto nos permite hacernos una idea fácilmente de qué keyword está coincidiendo mucho, para poder excluir fácilmente la categoría o la herramienta si tenemos demasiados falsos positivos.|loadjob myjobid podemos manipular la salida con los registros relevantes sin volver a buscar en todos los registros.Filtrar el 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"))
Excluye las palabras clave requeridas, el texto sin procesar o los tipos de palabra clave.
si decidimos excluir el tipo `greyware tool keyword` (palabras clave de herramientas legítimas que son abusadas por atacantes) porque este entorno tiene demasiados resultados para este tipo de herramientas, tenemos dos opciones:
- Filtrar al comienzo de nuestra búsqueda 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)
Añadí un metadata_keyword_type="offensive tool keyword" para centrarme solo en herramientas ofensivas que estoy seguro de que son utilizadas por actores maliciosos
Así que ese fue nuestro caso de uso para buscar en logs sin procesar en los logs de endpoint; si queremos buscar las palabras clave para logs de red (cualquier cosa que pueda registrar una consulta o una URL), simplemente lo cambiamos a:```
`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)
Ahora es lo mismo que la primera búsqueda, pero cambié la fuente de datos por mynetworklogs y añadí metadata_enable_proxy_detection=1 para que coincida con las palabras clave relevantes para networklogs (mejor tener registros de proxy y DNS para esto)
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)
#### Coincidir solo en el 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)
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)
#### Velocidad:
Si la velocidad es una preocupación o planeas implementar esto como una regla de detección programada, quizás quieras considerar dividir el lookup en diferentes lookups eligiendo la columna `metadata_keyword_type` o `metadata_tool` que quieras usar.
Ten en cuenta que filtrar con el comando `search` después del `|lookup` no acelera el proceso de búsqueda. Si quieres centrarte en una parte específica del lookup sin dividirlo, deberías usar el comando `|inputlookup` junto con la cláusula where. Aunque este método puede consumir más recursos de CPU, generalmente resulta en una ejecución más rápida. Para más detalles, consulta la documentación de Splunk sobre inputlookup: https://docs.splunk.com/Documentation/Splunk/latest/SearchReference/Inputlookup
#### Con ELK:
Si trabajas con Elastic Stack, hay muchas restricciones para las listas (no puedes usar caracteres especiales, espacios ...), tienes 3 opciones:
- Usar otra lista disponible aquí en el mismo repositorio https://github.com/mthcht/ThreatHunting-Keywords/tree/main/elk (no es una extracción directa de threathunting-keywords.csv, está modificada para ELK y no está actualizada)
- Usar reglas Sigma de "hunting", extraídas directamente de este proyecto https://github.com/mthcht/ThreatHunting-Keywords-sigma-rules con pysigma para la conversión
- Usar algunas de mis listas como lista de IOC con consultas comodín https://www.elastic.co/guide/en/elasticsearch/reference/8.15/query-dsl-wildcard-query.html#wildcard-top-level-params
### Dashboard Example

### Splunk4DFIR
Otro ejemplo del uso de los archivos csv del proyecto con Splunk para cazar en artefactos y registros de DFIR: https://github.com/mf1d3l/Splunk4DFIR

### Otras listas increíbles para detección
Mantengo algunos artefactos relevantes en listas separadas; estas listas son más precisas y pueden usarse en reglas de detección. Están disponibles en este [repositorio de GitHub](https://github.com/mthcht/awesome-lists/tree/main/Lists).
Encontrarás:
Mi hoja de recopilación de inteligencia para planificar sesiones de Threat Hunting

- 📋 Listas: https://github.com/mthcht/awesome-lists/tree/main/Lists
- 🕵️♂️ Guías de Threat Hunting: https://mthcht.medium.com/list/threat-hunting-708624e9266f
- 🚰 Named pipes sospechosos: [suspicious_named_pipe_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_named_pipe_list.csv)
- 🌐 TLDs sospechosos (actualizado automáticamente): [[suspicious_TLDs]](https://github.com/mthcht/awesome-lists/tree/main/Lists/TLDs)
- 🌐 ASNs sospechosos (actualizado automáticamente): [[suspicious ASNs]](https://github.com/mthcht/awesome-lists/tree/main/Lists/ASNs)
- 🔧 Servicios de Windows sospechosos: [suspicious_windows_services_names_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_windows_services_names_list.csv)
- ⏲️ Tareas de Windows sospechosas: [suspicious_windows_tasks_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_windows_tasks_list.csv)
- 🚪 Puerto de destino sospechoso: [suspicious_ports_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_ports_list.csv)
- 🛡️ Reglas de firewall sospechosas: [suspicious_windows_firewall_rules_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_windows_firewall_rules_list.csv)
- 🆔 User-agent sospechoso: [suspicious_http_user_agents_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_http_user_agents_list.csv)
- 📇 IDs USB sospechosos: [suspicious_usb_ids_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_usb_ids_list.csv)
- 🔢 Direcciones MAC sospechosas: [suspicious_mac_address_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_mac_address_list.csv)
- 📛 Hostnames sospechosos: [suspicious_hostnames_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/suspicious_hostnames_list.csv)
- 🧮 Metadatos de ejecutables: [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 sobre HTTPS: [dns_over_https_servers_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/dns_over_https_servers_list.csv)
- 📚 Hijacklibs (actualizado automáticamente): [hijacklibs_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/Hijacklibs/hijacklibs_list.csv)
- 🌐 Listas de nodos TOR (actualizado automáticamente): https://github.com/mthcht/awesome-lists/tree/main/Lists/TOR
- 🛠️ Lista LOLDriver (actualizado automáticamente): [loldrivers_only_hashes_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/Drivers/loldrivers_only_hashes_list.csv)
- 🛠️ Lista de bootloaders maliciosos (actualizado automáticamente): [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 (actualizado automáticamente): [ssl_certificates_malicious_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/SSL%20CERTS/ssl_certificates_malicious_list.csv)
- 🖥️ Detección de RMM: https://github.com/mthcht/awesome-lists/tree/main/Lists/RMM
- 👤🔑 Roles y grupos importantes para AD/EntraID/AWS: [[permissions]](https://github.com/mthcht/awesome-lists/tree/main/Lists/permissions)
- 💻🔒 Extensiones de archivo conocidas de ransomware: [ransomware_extensions_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/ransomware_extensions_list.csv)
- 💻🔒 Nombres de archivo conocidos de notas de rescate de ransomware: [ransomware_notes_list.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/ransomware_notes_list.csv)
- 📝 Reglas ASR de Windows: [windows_asr_rules.csv](https://github.com/mthcht/awesome-lists/blob/main/Lists/windows_asr_rules.csv)
- 🌐 Listas DNSTWIST (actualizado automáticamente): [DNSTWIST Dominios predeterminados + script](https://github.com/mthcht/awesome-lists/tree/main/Lists/DNSTWIST)
- 🌍 Listas de direcciones IP de VPN (actualizado automáticamente):
- 🛡️ 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 rangos IP de empresas (actualizado automáticamente): [Listas predeterminadas + script](https://github.com/mthcht/awesome-lists/tree/main/Lists/Ranges_IP_Address_Company_List/bgp.he.net)
- 🔗 Otras listas de correlación: https://github.com/mthcht/awesome-lists/tree/main/Lists/Others
- 📋 Listas que necesito terminar: https://github.com/mthcht/awesome-lists/tree/main/todo
Consulta estas [Guías](https://github.com/mthcht/awesome-lists/tree/main/Lists#how-to-use-the-lists) para usar algunas de las listas:
- [Búsquedas de servicios de Windows](https://detect.fyi/threat-hunting-suspicious-windows-service-names-2f0dceea204c)
- [Búsquedas de user-agents](https://mthcht.medium.com/threat-hunting-suspicious-user-agents-3dd764470bd0)
- [Búsquedas de DNS sobre HTTPS](https://mthcht.medium.com/detecting-dns-over-https-30fddb55ac78)
- [Búsquedas de TLD sospechosos](https://mthcht.medium.com/threat-hunting-suspicious-tlds-a742c2adbf58)
- [Búsquedas de HijackLibs](https://mthcht.medium.com/detect-dll-hijacking-techniques-from-hijacklibs-with-splunk-c760d2e0656f)
- [Búsquedas de phishing y DNSTWIST](https://detect.fyi/detecting-phishing-attempts-with-dnstwist-37c426b3bbb8)
- [Búsquedas de extensiones de navegador](https://mthcht.medium.com/detecting-browser-extensions-installations-e0ac2b45c46b)
- [C2 oculto a plena vista](https://mthcht.medium.com/c2-hiding-in-plain-sight-7a83963b9344)
- [Artefactos de HTML Smuggling](https://mthcht.medium.com/detecting-html-smuggling-phishing-attempts-15af824e60e4)
- [Búsquedas de PSEXEC y herramientas similares](https://mthcht.medium.com/detecting-psexec-and-similar-tools-c812bf3dca6c)
- [Detección de deslizamiento de tiempo](https://mthcht.medium.com/event-log-manipulations-1-time-slipping-55bf95631c40)
- [Named pipes sospechosos](https://medium.com/detect-fyi/threat-hunting-suspicious-named-pipes-a4206e8a4bc8)
... más [aquí](https://github.com/mthcht/awesome-lists/tree/main/Lists#how-to-use-the-lists)
## Caza de palabras clave en archivos para DFIR (sin SIEM)
Después de realizar una revisión exhaustiva de varias herramientas, descubrí que [ripgrep](https://github.com/BurntSushi/ripgrep) supera significativamente a sus competidores en lo que respecta a hacer coincidir rápidamente una extensa lista de patrones regex con cada línea de un archivo de registro grande o incluso de varios archivos a la vez. Resultó ser la solución más eficiente para manejar cantidades masivas de datos, ofreciendo una velocidad y flexibilidad inigualables.
### Caza de elementos maliciosos en archivos de registro con **Ripgrep** y la lista 'only_keywords_regex.txt'
#### `rg.exe -f .\only_keywords_regex.txt .\EvtxECmd_Output.csv --multiline --ignore-case`
- .\only_keywords_regex.txt sirve como archivo de origen para las palabras clave de threat hunting, transformadas en patrones regex para una coincidencia precisa. Estos patrones provienen del archivo threathunting-keywords.csv, que ha pasado por un proceso de conversión para una compatibilidad óptima con operaciones regex.
- .\EvtxECmd_Output.csv representa el archivo objetivo en el que se realizará la búsqueda. En este contexto, es un archivo .csv de un registro de eventos de Windows, producido al exportar registros evtx. Sin embargo, la flexibilidad de ripgrep te permite reemplazarlo con cualquier archivo de tu elección para operaciones detalladas de búsqueda de patrones.
- La opción --multiline permite a ripgrep manejar y hacer coincidir eficazmente patrones que abarcan varias líneas, ampliando significativamente el alcance de la búsqueda.
Obtendrás las líneas coincidentes de esta manera, con el número de línea (pero sin la palabra clave coincidente)


#### Mejor opción para archivos muy grandes (en 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 el archivo en el que buscar (en el ejemplo, un extracto de registros DFIR-ORC)
- `-patternFile`: el archivo que contiene los patrones regex `only_keywords_regex.txt`
- `-rgPath`: la ruta del ejecutable de ripgrep
contenido del script de PowerShell (incluido en el repositorio):```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
El resultado de la búsqueda estará en result_search.log en el mismo directorio que el script.

todo
En powershell es mucho más lento, pero si aún quieres hacerlo de esta manera, puedes usar el script de abajo; te indicará el número de línea coincidente y la palabra clave correspondiente:
powershell.exe -ep Bypass -File .\hunt_keywords_windows.ps1 -k .\only_keywords.txt -f .\EvtxECmd_Output.csv
[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>
### Reglas YARA

Todos los patrones de detección de este proyecto se exportan automáticamente a reglas yara en [ThreatHunting-Keywords-yara-rules](https://github.com/mthcht/ThreatHunting-Keywords-yara-rules)
Algunos ejemplos de búsqueda con las reglas yara:




## Tabla de datos rápida para buscar palabras clave
https://mthcht.github.io/ThreatHunting-Keywords/

## Falsos positivos
Contribuye y añade tus falsos positivos a la [lista](https://github.com/mthcht/ThreatHunting-Keywords/blob/main/_false_positives/false_positives_offensive_keywords.md) de falsos positivos esperados.
## Reglas SIGMA
Echa un vistazo al lookup traducido a [reglas SIGMA](https://github.com/mthcht/ThreatHunting-Keywords-sigma-rules), normalmente lo actualizo al mismo tiempo :)

## Mapeo de técnicas MITRE ATT&CK
con el complemento de splunk https://splunkbase.splunk.com/app/5742

Cobertura para 2242 herramientas (actualizado el 2024/08/30):

búsqueda en 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
y usa esta visualización de Splunk: https://splunkbase.splunk.com/app/5742

Paneles de Splunk (esto es solo un ejemplo; se puede aplicar una amplia variedad de filtros utilizando los campos disponibles en el archivo):
ejemplo de panel XML de Splunk:



¡Las contribuciones, los problemas y las solicitudes de funciones son bienvenidos!
``
Proporciona el nombre de la herramienta.
``
Proporciona un enlace al sitio web oficial de la herramienta o a su repositorio de código fuente (GitHub, GitLab, etc.). Si hay documentación disponible, inclúyela.
``
Describe el propósito, la funcionalidad y las características notables de la herramienta. Si no estás seguro, deja esto en blanco y revisaré la herramienta con más detalle.
``
Si tienes información sobre el uso indebido conocido o potencial de esta herramienta por parte de actores maliciosos, compártela aquí.
Elige la categoría más adecuada para la herramienta:
Decidiré si vale la pena añadir una herramienta a la lista. Las herramientas ampliamente utilizadas y reconocidas por la comunidad tienen más probabilidades de incluirse que las oscuras o nuevas.