Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
ThreatHunting-Keywords — Lista impresionante de palabras clave y artefactos para sesiones de Threat Hunting | Kitploit
Herramientas/GitHubGitHub/mthcht/threathunting-keywords
Herramientas DefensivasForensia DigitalInteligencia de AmenazasRespuesta a IncidentesRecursos CuradosAnálisis de Registros
GitHubmthcht/threathunting-keywords

ThreatHunting-Keywords

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

Ver Repositorio
669774hace 1 añoRevisado por Kitploit

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Sitio web
Compartir

ThreatHunting-Keywords

🎯 Lista de palabras clave para sesiones de ThreatHunting

image

Tabla de contenidos

  • ¿Qué es Threat Hunting?
    • Ventajas del Threat Hunting
    • Vinculando el Threat Hunting con los servicios principales
    • Nivel de madurez de la detección
    • Áreas clave de enfoque para la recopilación de inteligencia
    • Proceso de Threat Hunting dirigido
  • Archivos
  • ThreatHunting-Keywords para el equipo azul
  • ThreatHunting-Keywords para el equipo rojo
  • Contenido del lookup
  • Cazar con un SIEM
    • logs sin procesar
    • campos específicos
    • velocidad
    • ejemplo de dashboard
    • Splunk4DFIR
    • Con ELK es diferente
    • Otras listas increíbles para_detección
  • Cazar sin un SIEM
  • Caza optimizada para DFIR
  • Reglas YARA
  • Sitio web
  • Falsos positivos esperados
  • Reglas SIGMA
  • contribuir
  • ¿Qué es Threat Hunting ?

    image

    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.

    Ventajas del Threat Hunting:

    • 🔍 Identifica brechas de visibilidad
      • Detecta áreas donde la monitorización y la detección son insuficientes, abordando puntos ciegos en la red o los sistemas para mitigar amenazas ocultas.
    • 🛠️ Cubre brechas de detección
      • Busca de forma proactiva anomalías, precursores y TTPs que pueden no generar alertas
    • ⚙️ Mejora la eficiencia del SOC
      • Integra los conocimientos del threat hunting en los flujos de trabajo del SOC para descubrir eventos que las detecciones estáticas podrían pasar por alto. Al reducir los falsos positivos y escalar eventos ignorados, permite a los analistas del SOC centrarse en amenazas críticas y refinar la lógica de detección para uso futuro.
    • 🚀 Mejora la detección de amenazas y apoya la mejora continua
      • Identifica amenazas avanzadas, desconocidas u ocultas que evaden los sistemas de detección automatizados y retroalimenta el proceso del SOC con datos valiosos, mejorando las herramientas, la formación y las capacidades de detección futuras
    • 🛡️ Reduce la superficie de ataque
      • Descubre sistemas, aplicaciones y TI en la sombra (shadow IT) no gestionados o no autorizados dentro de la red, permitiendo a las organizaciones abordar los puntos ciegos de seguridad y reducir la exposición a posibles amenazas.

    Vinculando el Threat Hunting con los servicios principales

    image

    Ciclo de vida del Threat Hunting en las operaciones del SOC

    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

    SOC_Process_Threat_Hunting_to_detection

    Nivel de madurez de la detección

    image

    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.

    Lista de verificación de Threat Hunting - Áreas clave de enfoque para la recopilación de inteligencia

    image

    Ejemplo de metodología de Threat Hunting dirigido

    image

    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

    Archivos

    • ThreatHunting-Keywords
    • Keywords de herramientas greyware
    • Keywords de herramientas ofensivas
    • Keywords de firmas de proveedores
    • Herramientas individuales (un archivo csv por herramienta)
    • Solo las keywords
    • Solo las keywords regex
    • Solo las keywords regex (mejor rendimiento)
    • Script de Powershell para cazar en archivos
    • Reglas Yara
    • Reglas Sigma

    Para el equipo azul:

    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 el equipo rojo:

    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.

    Contenido del archivo de Threat Hunting Keywords:

    • 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.

      • Si puedes buscar el keyword en logs de endpoint, el valor es 1 (habilitado).
      • Si el keyword no es relevante para logs de endpoint, el valor es 0 (deshabilitado).
    • 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)

      • Si puedes buscar el keyword en logs de actividad de red, el valor es 1 (habilitado).
      • Si el keyword no es relevante para logs de actividad de red, el valor es 0 (deshabilitado).
    • 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.

    Usa la lista para cazar con Splunk:

    • sube la lista threathunting-keywords.csv a Splunk

    • crea una definición de lookup llamada threathunting-keywords para el lookup threathunting-keywords.csv

      • en las opciones avanzadas, añade el tipo de coincidencia (Match type) WILDCARD(keyword) y asegúrate de que Case sensitive match no esté marcado

      image

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

    root@kitploit:~
    - 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`:
    ![image](https://assets.kitploit.com/production/public/readmes/48741/204eb8e71d12257660c7166cb5f050747877e1968d7ff1f21812967d64355ca0.png)
    
    
    
    ### 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.

    image

    • 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)
      • Incorporé intencionalmente una macro en los ejemplos para demostrar que la exploración inicial se puede realizar con cualquier método que se adapte a las necesidades, ya sea un modelo de datos, tstats, etiquetas, índice/tipo de origen. Si bien tstats junto con un datamodel suele ser la vía más rápida, filtra con el comando 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.
    • Cuando mi búsqueda termina, ¿cómo puedo analizar los resultados? Tendrás los registros sin procesar ordenados por keywords y tipos de keyword; usando |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"))

    root@kitploit:~
    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

    • O filtrar después de nuestra búsqueda inicial (para ganar mucho tiempo):``` | loadjob 1684146257.1495958 | search metadata_keyword_type="offensive tool keyword"
    root@kitploit:~
    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)


    Busca las palabras clave en otros campos 🙂 (url,process,commandline,query...):

    Coincidir solo en el 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)

    root@kitploit:~
    #### 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)
    

    Coincidir en varios campos al mismo tiempo, ejemplo para registros 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)

    root@kitploit:~
    #### 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
    ![image](https://assets.kitploit.com/production/public/readmes/48741/df177e7f2584b823c311a2b223eed8b237d8a72c05d0afb9d6b6f350e42ccda0.png)
    
    ### 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
    ![image](https://assets.kitploit.com/production/public/readmes/48741/73d54c5b146c34685ebac4ed7ed2a9da11a3f90e6ae9ac0a4b17118d7895cbe3.png)
    
    ### 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
    
    ![intelligence gathering sheet](https://assets.kitploit.com/production/public/readmes/48741/498b188eaebabe5a7077300eeff16daee903ed30d0b1797b82c208a54ba1424d.png)
    
    
    - 📋 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)
    
    ![image](https://assets.kitploit.com/production/public/readmes/48741/d205ae3caf99906a03818c202e8811b669948e2f68b88cc137cba8cf0e43b69f.png)
    
    ![image](https://assets.kitploit.com/production/public/readmes/48741/e1b213fc63e1ec2914e0f1eb3263d17aa960eb50672fd18986a0f75d50e9c379.png)
    
    #### 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.

    image

    Mejor opción para archivos muy grandes (en linux):

    todo

    Caza de malware en archivos solo con powershell y la lista 'only_keywords.txt ' (más lento no recomendado)

    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

    ```powershell param( [Parameter(Mandatory=$true)] [string]$file,
    root@kitploit:~
    [Parameter(Mandatory=$true)]
    [string]$kw
    

    )

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

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

    root@kitploit:~
    $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"

    root@kitploit:~
    </details>
    
    ### Reglas YARA
    ![image](https://assets.kitploit.com/production/public/readmes/48741/e1355c1b331e4e617189507532d5fc1045ae7eb085259c2e6a3c51338b88fcf2.png)
    
    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:
    ![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)
    
    ## Tabla de datos rápida para buscar palabras clave
    https://mthcht.github.io/ThreatHunting-Keywords/
    ![image](https://assets.kitploit.com/production/public/readmes/48741/477608f39dee047778948ef170316f7d59e2fb0e2437b53e39e7de6900ecb900.png)
    
    ## 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 :) 
    
    ![image](https://assets.kitploit.com/production/public/readmes/48741/298b4f42a0702b8a14376577a5fc2c670aa7a8246f9ee41cad9b39d573df0432.png)
    
    ## Mapeo de técnicas MITRE ATT&CK
    
    con el complemento de splunk https://splunkbase.splunk.com/app/5742
    ![image](https://assets.kitploit.com/production/public/readmes/48741/6605c5297f2d2536e18f593e2a3f5ec02ed5e66adbe4970247a3eccba0cbe31d.png)
    
    Cobertura para 2242 herramientas (actualizado el 2024/08/30):
    ![image](https://assets.kitploit.com/production/public/readmes/48741/eafcd79072b45d2a583d286d9d03084c01dba1de233c7b77f208f6c379081d84.png)
    
    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

    image image

    Matriz de herramientas

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

    Grupos de actores de amenazas por herramientas en este proyecto

    ejemplo de panel XML de 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 ```

    image

    image

    image

    🤝 Contribuciones

    ¡Las contribuciones, los problemas y las solicitudes de funciones son bienvenidos!

    Si quieres que añada una herramienta a la lista, crea un issue con esta plantilla:


    Nombre de la herramienta:

    ``

    Proporciona el nombre de la herramienta.

    Sitio web oficial o enlace al código fuente:

    ``

    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.

    Descripción de la herramienta:

    ``

    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.

    Uso conocido por actores maliciosos (si corresponde):

    ``

    Si tienes información sobre el uso indebido conocido o potencial de esta herramienta por parte de actores maliciosos, compártela aquí.

    Clasificación de la herramienta:

    Elige la categoría más adecuada para la herramienta:

    • Ofensiva (Utilizada principalmente por atacantes, no legítima para uso general)
    • Greyware (Herramienta legítima que suele ser abusada por actores maliciosos)
    • Firmas/Palabras clave genéricas (Firmas o términos comunes vinculados a malware según lo detectan los productos de seguridad)

    Propón cambios a la lista con un PR (proporciona comentarios sobre falsos positivos, muestra de registros si puedes), si una palabra clave está generando demasiados falsos positivos en demasiados entornos, podemos eliminarla)

    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.

    Descargar herramienta