Identificación · Triaje inicial

Lo primero ante una alerta de brute force es confirmar si es TP o FP. Muchos FP vienen de usuarios con contraseñas caducadas, apps con credenciales hardcodeadas o scanners legítimos. La clave está en el patrón: una IP única intentando 50 cuentas distintas (spraying) es muy distinto de un usuario fallando 10 veces (probable olvido).

Preguntas clave del triaje

• ¿Cuántos intentos fallidos? ¿En qué ventana de tiempo?
• ¿Una IP origen o muchas? ¿Geolocalización (impossible travel)?
• ¿Una cuenta objetivo o varias? (1→muchas = spraying; muchas→1 = password guessing)
• ¿Hubo algún éxito (4624) tras los fallos (4625)? — esto cambia la severidad a CRÍTICA
• ¿La cuenta atacada es privilegiada (Domain Admin, servicio crítico)?

Detección · SPL (Splunk)

index=wineventlog EventCode=4625
| bin _time span=10m
| stats count dc(Account_Name) as users_targeted values(Account_Name) as accounts by _time, src_ip
| where count >= 10
| sort - count

index=wineventlog EventCode=4625
| bin _time span=30m
| stats dc(Account_Name) as users_targeted count by src_ip
| where users_targeted >= 5 AND count >= 10
| sort - users_targeted

index=wineventlog (EventCode=4624 OR EventCode=4625) Logon_Type IN (3,10)
| transaction src_ip Account_Name maxspan=15m
| where eventcount > 10 AND searchmatch("EventCode=4624")
| table _time src_ip Account_Name eventcount

index=linux source="/var/log/auth.log" "Failed password"
| rex "Failed password for (invalid user )?(?<user>\S+) from (?<src_ip>\S+)"
| bin _time span=10m
| stats count dc(user) as users by _time, src_ip
| where count >= 15

Detección · KQL (Sentinel / Defender)

SecurityEvent
| where EventID == 4625
| where TimeGenerated > ago(1h)
| summarize FailedCount = count(),
            TargetedAccounts = dcount(TargetUserName),
            Accounts = make_set(TargetUserName, 20)
  by IpAddress, bin(TimeGenerated, 10m)
| where FailedCount >= 10
| order by FailedCount desc

SigninLogs
| where TimeGenerated > ago(6h)
| summarize Failed = countif(ResultType != "0"),
            Success = countif(ResultType == "0")
  by UserPrincipalName, IPAddress, bin(TimeGenerated, 30m)
| where Failed >= 10 and Success >= 1
| order by TimeGenerated desc

Contención inmediata

• Bloquear IP origen en firewall perimetral / WAF si es externa.
• Forzar reset de contraseña de la cuenta si hubo éxito o si la cuenta es privilegiada.
• Habilitar MFA si no estaba activo (especialmente OWA/M365).
• Desactivar la cuenta temporalmente si hay sospecha alta de compromiso.
• Revisar sesiones activas (token theft, sesiones desde la IP atacante) y revocarlas.

Criterio de escalado a L2

• Hubo autenticación exitosa después del ataque.
• La cuenta es privilegiada (admin de dominio, cuenta de servicio crítica).
• Patrón sostenido en el tiempo (>24h) o desde múltiples IPs coordinadas.
• Indicios de movimiento lateral o ejecución posterior al login → ver PB-05.

Evidencia a recoger

Identificación · Artefactos a examinar

El objetivo es determinar si el correo es malicioso y, si lo es, extraer IoCs para detección, bloqueo y threat intel. Cuatro bloques de artefactos según BTL1: cabeceras, cuerpo, URLs y adjuntos.

Workflow de análisis

1. Aislar el email en formato .eml o .msg sin reenviar inline.
2. Cabeceras: pegar en MXToolbox Header Analyzer o Google Admin Toolbox. Verificar SPF/DKIM/DMARC.
3. URLs: extraer (defanged), expandir acortadores con urlscan.io, comprobar reputación en VirusTotal + URLhaus.
4. Adjuntos: calcular hash (MD5/SHA256), buscar en VirusTotal. Si no aparece → sandbox.
5. Extraer IoCs: IPs, dominios, hashes, asuntos, direcciones email.
6. Pivotar en SIEM: ¿quién más recibió esto? ¿alguien hizo clic?

Detección · SPL (Splunk)

index=email (sender="atacante@dominio-falso.com" OR subject="Factura urgente pendiente")
| stats count values(recipient) as destinatarios values(subject) as asuntos by sender
| sort - count

index=proxy url="*malicious-site.com*" OR url="*phishing-domain.tld*"
| stats count earliest(_time) as first_click latest(_time) as last_click by user, src_ip, url
| sort - count

index=dns OR index=proxy query="*.tld-sospechoso.*"
| stats count values(src_ip) as origenes by query
| where count > 0
| sort - count

Detección · KQL (Sentinel / Defender)

EmailEvents
| where TimeGenerated > ago(7d)
| where SenderFromAddress == "atacante@dominio-falso.com"
   or Subject contains "Factura urgente"
| join kind=leftouter EmailUrlInfo on NetworkMessageId
| project TimeGenerated, RecipientEmailAddress, Subject, Url, DeliveryAction
| order by TimeGenerated desc

UrlClickEvents
| where TimeGenerated > ago(7d)
| where Url contains "malicious-site.com"
| project TimeGenerated, AccountUpn, Url, ActionType, IPAddress

Contención y erradicación

• Purgar correo de todos los buzones (M365: Threat Explorer → Take action → Soft/Hard delete).
• Bloquear remitente y dominio en gateway de correo (Defender, Proofpoint, Mimecast).
• Bloquear URLs/IPs maliciosas en proxy/firewall/DNS.
• Bloquear hash de adjunto en EDR.
• Si alguien hizo clic e introdujo credenciales: reset password, revocar sesiones, MFA enrollment forzado, revisar reglas de bandeja (forwarding malicioso es típico).
• Si alguien ejecutó adjunto: aislar endpoint (network containment EDR) y pasar a PB-03 / PB-04.

IoCs a extraer y registrar

Identificación · Triaje del proceso

Una alerta de malware suele venir del EDR o del AV. El triaje L1 consiste en validar la detección, entender qué hizo el proceso y decidir si el host queda contenido o no.

• Hash del binario → VirusTotal, MalwareBazaar (¿muestra conocida? ¿familia?).
• Padre y abuelo del proceso → winword.exe → powershell.exe → ? es típico de macro.
• Argumentos de línea de comandos → base64, -enc, DownloadString, IPs raras.
• Conexiones de red del proceso → ¿beacons?
• Persistencia creada → Run keys, tareas programadas, servicios, WMI subscriptions.
• Otros hosts con el mismo hash o nombre de fichero.

Detección · SPL (Splunk + Sysmon)

index=sysmon EventCode=1 Image="*powershell.exe"
  (CommandLine="*-enc*" OR CommandLine="*-EncodedCommand*"
   OR CommandLine="*FromBase64String*" OR CommandLine="*DownloadString*")
| table _time host User ParentImage Image CommandLine
| sort - _time

index=sysmon EventCode=1
  ParentImage IN ("*winword.exe","*excel.exe","*powerpnt.exe","*outlook.exe")
  Image IN ("*cmd.exe","*powershell.exe","*wscript.exe","*cscript.exe","*mshta.exe","*rundll32.exe")
| table _time host User ParentImage Image CommandLine

index=sysmon EventCode=13
  TargetObject IN (
    "*\\Software\\Microsoft\\Windows\\CurrentVersion\\Run*",
    "*\\Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce*",
    "*\\Services\\*"
  )
| table _time host Image TargetObject Details

index=sysmon EventCode=1 SHA256="A3B5C7D9...HASH..."
| stats count values(Image) as paths values(CommandLine) as cmds by host
| sort - count

Detección · KQL (Defender for Endpoint)

DeviceProcessEvents
| where TimeGenerated > ago(24h)
| where InitiatingProcessFileName in~ ("winword.exe","excel.exe","powerpnt.exe","outlook.exe")
| where FileName in~ ("cmd.exe","powershell.exe","mshta.exe","wscript.exe","cscript.exe","rundll32.exe")
| project TimeGenerated, DeviceName, AccountName,
          InitiatingProcessFileName, FileName, ProcessCommandLine
| order by TimeGenerated desc

DeviceProcessEvents
| where SHA256 == "A3B5C7D9...HASH..."
| summarize Hosts = make_set(DeviceName), Count = count() by FileName, SHA256

Contención inmediata

• Aislar el host en la red desde EDR (network containment / isolation).
• Matar el proceso y sus hijos.
• Bloquear el hash en EDR / AV (politica organizacional).
• Bloquear IPs/dominios C2 en firewall/proxy/DNS.
• Deshabilitar la cuenta si hubo robo de credenciales o si ejecutó como admin.
• Preservar evidencia: triage package del EDR (memoria, procesos, conexiones, persistencia) antes de tocar nada.

Live response · Comandos

tasklist /v
wmic process get Name,ProcessId,ParentProcessId,CommandLine
netstat -anob
schtasks /query /fo LIST /v
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Run
Get-WmiObject Win32_StartupCommand

ps auxf
ss -tunap
lsof -i
crontab -l ; ls /etc/cron.*
cat ~/.bash_history
last ; w
find / -mtime -2 -type f 2>/dev/null

Criterio de escalado a L2

• Confirmado multi-host (mismo hash o C2 en >1 endpoint).
• Indicios de movimiento lateral → PB-05.
• Persistencia compleja (WMI, servicios, DLL hijacking).
• Sospecha de ransomware → PB-04 inmediatamente.

Indicadores de ransomware activo

• Cambios masivos de extensión de fichero (.lockbit, .encrypt, etc.).
• Notas de rescate aparecidas en cada carpeta (readme.txt, HOW_TO_DECRYPT.html).
• Borrado de shadow copies: vssadmin delete shadows, wbadmin delete catalog.
• Deshabilitación de recovery: bcdedit /set bootstatuspolicy ignoreallfailures.
• Procesos consumiendo CPU de forma sostenida en muchos hosts simultáneamente.
• Servicios parados: bases de datos, AV, backups.

Detección · SPL (Splunk + Sysmon)

index=sysmon EventCode=1
  (CommandLine="*vssadmin*delete*shadows*"
   OR CommandLine="*wbadmin*delete*"
   OR CommandLine="*wmic*shadowcopy*delete*"
   OR CommandLine="*bcdedit*recoveryenabled*No*")
| table _time host User ParentImage Image CommandLine

index=sysmon EventCode=11
| bin _time span=5m
| stats count by _time, host
| where count > 500
| sort - count

index=sysmon EventCode=11
  TargetFilename IN ("*readme*.txt","*how_to_decrypt*","*restore_files*","*ransom*","*.lockbit","*.locked")
| stats count values(host) as hosts by TargetFilename
| sort - count

Detección · KQL (Defender)

DeviceProcessEvents
| where TimeGenerated > ago(1h)
| where ProcessCommandLine has_any ("vssadmin delete shadows",
        "wbadmin delete", "wmic shadowcopy delete",
        "bcdedit /set", "wevtutil cl")
| project TimeGenerated, DeviceName, AccountName, ProcessCommandLine

Contención agresiva (minutos)

1. Aislar TODOS los hosts con indicios desde EDR. No esperes confirmación: aísla y verifica después.
2. Desconectar shares de red y servidores de ficheros para parar la propagación.
3. Bloquear C2 en perímetro (firewall, proxy, DNS).
4. Deshabilitar cuentas usadas por el atacante (sobre todo de servicio/admin).
5. Apagar lo que NO esté infectado todavía si la propagación es activa y agresiva (decisión coordinada con IR/Sistemas).
6. Notificar inmediatamente: IR Manager, CISO, jurídico, comunicación. Activar el plan de crisis.

Evidencia clave a preservar

• Muestra del binario ransomware (hash + sample para sandbox/CTI).
• Nota de rescate completa (incluye ID de víctima y wallet).
• Memoria RAM de al menos un host afectado (claves de cifrado pueden estar en memoria).
• Logs de EDR de los 7-14 días previos (acceso inicial y propagación).
• Logs de DC: autenticaciones y creaciones de cuenta.
• Logs de backup: ¿qué intentó borrar el atacante?

Recovery (visión L2/L3 — qué esperar)

El L1 no lidera recuperación, pero debe entender el flujo: validar backups limpios y previos al compromiso → reconstruir hosts desde imagen → restaurar datos → monitorización intensiva post-restore (la reinfección por persistencia residual es muy común) → cambio masivo de credenciales del dominio (KRBTGT incluida si hay sospecha de Golden Ticket).

Patrones típicos a buscar

El atacante ya está dentro. El L1 debe buscar saltos host-a-host con cuentas privilegiadas, usando técnicas que abusan de funcionalidad legítima de Windows.

• Logon Type 3 (Network) con NTLM en lugar de Kerberos en hosts no-servidor → señal de Pass-the-Hash.
• Creación de servicio remoto (EID 7045) con nombre random → PsExec o similares.
• Conexiones SMB a ADMIN$, C$, IPC$ desde una workstation a otra.
• WMI remoto (wmic /node:...) y procesos hijos de wmiprvse.exe.
• WinRM (puertos 5985/5986) entre estaciones de trabajo.
• RDP (EID 4624 Logon Type 10) en horarios o desde orígenes raros.

Detección · SPL

index=wineventlog EventCode=4624 Logon_Type=3
  Authentication_Package_Name=NTLM
  NOT Account_Name IN ("ANONYMOUS LOGON","-","*$")
| stats count values(Workstation_Name) as src_hosts values(host) as dst_hosts by Account_Name
| where count > 0
| sort - count

index=wineventlog EventCode=7045
  (Service_Name="PSEXESVC" OR Service_File_Name="*\\admin$\\*"
   OR Service_File_Name="*\\PSEXEC*" OR Service_Type="user mode service")
| table _time host Service_Name Service_File_Name Service_Account

index=sysmon EventCode=1 ParentImage="*wmiprvse.exe"
  Image IN ("*cmd.exe","*powershell.exe","*rundll32.exe","*mshta.exe")
| table _time host User ParentImage Image CommandLine

index=wineventlog EventCode=4624 Logon_Type IN (3,10)
| bin _time span=30m
| stats dc(host) as hosts_count values(host) as hosts by _time, Account_Name
| where hosts_count >= 5
| sort - hosts_count

Detección · KQL (Defender)

DeviceLogonEvents
| where TimeGenerated > ago(24h)
| where LogonType in ("Network","RemoteInteractive")
| summarize Hosts = dcount(DeviceName), HostList = make_set(DeviceName, 20)
  by AccountName, bin(TimeGenerated, 30m)
| where Hosts >= 5
| order by Hosts desc

Contención

• Aislar tanto el host origen (paciente cero) como los hosts destino confirmados.
• Deshabilitar la cuenta que se está usando para moverse lateralmente.
• Forzar reset de contraseña de esa cuenta y de cualquier cuenta vista en hosts comprometidos.
• Revisar Domain Admins y Enterprise Admins — si una de esas cuentas se movió lateralmente, escalado inmediato.
• Revocar Kerberos tickets (en casos graves: reset doble de KRBTGT).
• Bloquear SMB/RPC entre estaciones de trabajo (lo normal es que no exista; segmentación de red).

Patrones a buscar

La exfiltración rara vez es "un fichero gigante saliendo". Suele ser tráfico anómalo en volumen o destino respecto al baseline del usuario/host. La detección depende de metadatos de red (NetFlow, proxy, firewall) más que del contenido cifrado.

• Volumen anómalo de subida respecto a la línea base del usuario.
• Destinos atípicos: pastebin.com, transfer.sh, anonfiles, mega.nz, IP raras.
• DNS tunneling: queries muy largas, subdominios random, alto volumen al mismo dominio.
• Uso anómalo de cloud storage (Google Drive, Dropbox, OneDrive personal).
• Correo con adjuntos grandes a dominios externos personales.
• Horarios anómalos: subidas en madrugada, fines de semana.

Detección · SPL

index=proxy
| bin _time span=1h
| stats sum(bytes_out) as bytes_uploaded by _time, src_ip, user
| eventstats avg(bytes_uploaded) as avg stdev(bytes_uploaded) as stdev by user
| where bytes_uploaded > avg + 3 * stdev AND bytes_uploaded > 100000000
| sort - bytes_uploaded

index=proxy dest_domain IN (
  "*pastebin.com","*transfer.sh","*anonfiles.com","*mega.nz",
  "*wetransfer.com","*sendspace.com","*filebin.net")
| stats sum(bytes_out) as bytes count by user, dest_domain
| where bytes > 10000000
| sort - bytes

index=dns
| eval qlen=len(query)
| stats count avg(qlen) as avg_len max(qlen) as max_len by src_ip, query_domain
| where count > 1000 AND avg_len > 50
| sort - count

index=firewall action=allowed
| stats sum(bytes_out) as out sum(bytes_in) as in by src_ip dest_ip
| eval ratio = if(in>0, out/in, out)
| where out > 50000000 AND ratio > 10
| sort - out

Detección · KQL (Defender)

DeviceNetworkEvents
| where TimeGenerated > ago(24h)
| where RemoteUrl has_any ("pastebin.com","transfer.sh","anonfiles","mega.nz")
| summarize Bytes = sum(SentBytes), Count = count()
  by DeviceName, InitiatingProcessAccountName, RemoteUrl
| where Bytes > 10000000
| order by Bytes desc

Contención

• Bloquear el destino (IP, dominio) en firewall/proxy.
• Aislar el host si la exfiltración está en curso.
• Suspender la cuenta sospechosa (sobre todo en escenarios de insider).
• Cuantificar lo exfiltrado: volumen, destino, horario, qué datos (revisar accesos a fileshares).
• Notificar a DPO/Legal si hay sospecha de datos personales (RGPD: 72h).

Patrones en logs HTTP

Detección · SPL

index=web (uri="*UNION*SELECT*" OR uri="*' OR '1'='1*"
           OR uri="*sleep(*" OR uri="*--*" OR uri="*xp_cmdshell*"
           OR uri="*information_schema*")
| stats count values(uri) as urls by src_ip
| sort - count

index=web (uri="*../*" OR uri="*..%2f*" OR uri="*%2e%2e%2f*"
           OR uri="*etc/passwd*" OR uri="*windows/win.ini*")
| stats count values(uri) as urls by src_ip status

index=sysmon EventCode=1
  ParentImage IN ("*w3wp.exe","*httpd*","*nginx*","*java*","*tomcat*","*php-fpm*")
  Image IN ("*cmd.exe","*powershell.exe","*bash","*sh","*nc","*wget","*curl")
| table _time host User ParentImage Image CommandLine

Detección · KQL

DeviceProcessEvents
| where InitiatingProcessFileName in~ ("w3wp.exe","httpd","nginx","tomcat","php-fpm")
| where FileName in~ ("cmd.exe","powershell.exe","bash","sh","nc","wget","curl")
| project TimeGenerated, DeviceName, InitiatingProcessFileName,
          FileName, ProcessCommandLine
| order by TimeGenerated desc

Contención

• Bloquear IP atacante en WAF / firewall.
• Activar reglas WAF específicas (OWASP CRS para SQLi/XSS).
• Tirar el servicio temporalmente si hay RCE confirmado y no hay parche aún.
• Buscar web shells en directorios web: ficheros recientes, hashes raros, ficheros con permisos extraños.
• Revisar conexiones salientes del servidor web (¿llama a casa?).
• Cambiar credenciales de BBDD, app y APIs si SQLi confirmado.

Patrones típicos

• Accesos fuera de horario habitual o desde geografías nuevas.
• Descargas masivas de fileshares o repositorios (SharePoint, Confluence, GitLab).
• Uso anómalo de USB o impresoras (volumen de impresión).
• Reenvíos a correo personal (reglas de Outlook, forwarding).
• Subidas a cloud personal (Drive, Dropbox cuenta privada).
• Acceso a recursos fuera de su rol (curiosity browsing).
• Cambios bruscos de comportamiento tras renuncia o conflicto reportado.

Detección · SPL

index=wineventlog EventCode=4624 Logon_Type IN (2,10,11)
| eval hour=strftime(_time,"%H"), wday=strftime(_time,"%w")
| where (hour<7 OR hour>20) OR wday IN ("0","6")
| stats count by Account_Name host hour wday
| sort - count

index=fileserver action=read
| bin _time span=1h
| stats count sum(file_size) as bytes by _time, user
| where count > 500 OR bytes > 1000000000
| sort - bytes

index=o365 Operation IN ("New-InboxRule","Set-InboxRule","Set-Mailbox")
  (Parameters="*ForwardTo*" OR Parameters="*ForwardingSmtpAddress*"
   OR Parameters="*RedirectTo*")
| table _time UserId Parameters ClientIP

index=wineventlog EventCode IN (6416,4663)
  (ObjectName="*USBSTOR*" OR DeviceDescription="*Disk*")
| stats count values(SubjectUserName) as user by host
| sort - count

Contención (con cabeza)

• NO actuar unilateralmente. Coordinar con IR Manager, RRHH y Legal antes de bloquear.
• Aumentar logging sobre el usuario sin que lo perciba (más eventos, captura más larga).
• Preservar evidencia: imagen de disco si va a derivar en proceso disciplinario o legal.
• Documentar cadena de custodia con hashes (MD5/SHA256), responsable, fecha/hora.
• Cuando se decida actuar: revocar accesos de golpe (AD, SaaS, VPN, físico) en coordinación con RRHH.

Patrones típicos de C2 (BTL1 — Network Analysis)

• Beaconing periódico: conexiones a intervalos casi fijos a la misma IP/dominio (cada 60s, 5min, 1h...).
• Conexiones pequeñas y regulares con ratio bytes_in/bytes_out balanceado o muy asimétrico.
• Dominios recién registrados (newly registered domains, NRDs).
• DGA (Domain Generation Algorithms): nombres aleatorios xkj19asdfk.tld.
• DNS con queries muy largas a un mismo dominio (tunneling).
• HTTPS a IPs en lugar de dominios, certificados autofirmados o JA3 raros.
• User-Agents anómalos o ausentes (Cobalt Strike, Empire, Sliver).

Detección · SPL

index=firewall action=allowed
| sort 0 src_ip dest_ip _time
| streamstats current=f last(_time) as prev_time by src_ip dest_ip
| eval interval = _time - prev_time
| stats count avg(interval) as avg_int stdev(interval) as stdev_int by src_ip dest_ip
| where count > 20 AND stdev_int < (avg_int * 0.1) AND avg_int > 30
| sort - count

index=dns
| stats earliest(_time) as first_seen count by query
| where first_seen > relative_time(now(), "-7d")
| sort first_seen

index=proxy
| search http_user_agent IN ("*Cobalt*","*Empire*","*Mythic*","*Sliver*","Mozilla/4.0*")
| stats count by src_ip dest_domain http_user_agent

index=sysmon EventCode=3
  NOT Image IN ("*chrome.exe","*firefox.exe","*msedge.exe","*iexplore.exe","*outlook.exe","*teams.exe")
  DestinationPort IN (80,443,8080,8443)
| stats count values(DestinationIp) as ips by host Image
| sort - count

Detección · KQL

DeviceNetworkEvents
| where TimeGenerated > ago(24h)
| where RemotePort in (80,443,8080,8443)
| where InitiatingProcessFileName !in~ ("chrome.exe","firefox.exe","msedge.exe","outlook.exe","teams.exe")
| summarize Count = count(), Hosts = make_set(RemoteIP, 10)
  by DeviceName, InitiatingProcessFileName
| where Count > 50
| order by Count desc

Contención

• Bloquear IPs/dominios C2 en firewall/proxy/DNS sinkhole.
• Aislar el host con beacon confirmado (EDR network containment).
• Cazar el implant en disco y memoria (proceso, persistencia).
• Buscar otros hosts hablando con el mismo destino → propagación lateral.
• Threat intel: cruzar el dominio/IP con VirusTotal, AlienVault OTX, ThreatFox, URLhaus.

Patrones a buscar

• Token impersonation: proceso de usuario normal hereda SID de SYSTEM o admin.
• UAC bypass: fodhelper.exe, eventvwr.exe, computerdefaults.exe spawn de procesos elevados.
• Modificación de servicios existentes para ejecutar comandos.
• Adición a grupos privilegiados: Administrators, Domain Admins.
• Dumping de credenciales: lsass.exe acceso desde proceso no autorizado (mimikatz).
• Asignación de derechos peligrosos: SeDebugPrivilege, SeImpersonatePrivilege.

Detección · SPL

index=sysmon EventCode=10 TargetImage="*lsass.exe"
  (GrantedAccess="0x1010" OR GrantedAccess="0x1410" OR GrantedAccess="0x143A")
  NOT SourceImage IN ("*MsMpEng.exe","*csrss.exe","*wininit.exe","*services.exe")
| table _time host SourceImage TargetImage GrantedAccess

index=sysmon EventCode=1
  ParentImage IN ("*fodhelper.exe","*eventvwr.exe","*computerdefaults.exe","*sdclt.exe")
  Image IN ("*cmd.exe","*powershell.exe")
| table _time host ParentImage Image CommandLine

index=wineventlog EventCode IN (4728,4732,4756)
  Target_Account_Name IN ("Domain Admins","Enterprise Admins","Administrators","Schema Admins")
| table _time host Subject_User_Name Member_Account_Name Target_Account_Name

index=wineventlog EventCode=4672
  NOT Account_Name IN ("SYSTEM","LOCAL SERVICE","NETWORK SERVICE","*$")
  Privileges IN ("*SeDebugPrivilege*","*SeImpersonatePrivilege*","*SeTcbPrivilege*","*SeLoadDriverPrivilege*")
| table _time host Account_Name Privileges

Contención

• Aislar el host donde se haya producido la escalada.
• Deshabilitar la cuenta ya escalada y revocar tokens/tickets.
• Revisar y revertir cambios en grupos (quitar la cuenta añadida indebidamente).
• Reset de contraseña de TODAS las cuentas que hayan iniciado sesión en ese host (sus hashes pueden estar en LSASS).
• Si se dumpeó LSASS: considerar el host comprometido a nivel de credenciales — reset de password de cualquier usuario que haya tocado ese host recientemente.

Tipos y patrones

Detección · SPL

index=firewall direction=inbound dest_port IN (80,443)
| bin _time span=1m
| stats count by _time dest_ip
| eventstats avg(count) as avg stdev(count) as stdev by dest_ip
| where count > avg + 5 * stdev
| sort - count

index=firewall tcp_flag=SYN action=allowed
| stats count dc(src_ip) as src_count by dest_ip _time
| bin _time span=1m
| where count > 10000

index=web
| bin _time span=1m
| stats count dc(src_ip) as ips by _time uri
| where count > 5000 AND ips > 500
| sort - count

Contención

• Notificar al proveedor anti-DDoS (Cloudflare, Akamai, ISP) si existe contrato — es lo primero.
• Activar rate limiting en WAF / load balancer.
• Geo-blocking temporal si el ataque viene de regiones específicas.
• Blackhole routing de IPs claramente maliciosas (cuidado con FPs masivos).
• Escalar capacidad (autoscaling) si la app lo permite — comprar tiempo.
• Vigilar otros ataques en paralelo: el DDoS suele usarse como cortina de humo para exfiltración u otros incidentes.

El L1 en este tipo de incidente

El L1 rara vez es el primero en detectar un supply chain por sí solo — normalmente llega como aviso externo: CTI feed, advisory de un fabricante, alerta de CERT/CSIRT, noticia pública. El papel del L1 es contener rápido y cazar IoCs en el parque.

Triggers típicos

• Advisory del fabricante de una herramienta crítica que tienes desplegada.
• IoCs publicados por CISA, INCIBE-CERT, CCN-CERT, MITRE, vendor TI.
• Comportamiento anómalo de software firmado y legítimo (binarios buenos haciendo cosas malas).
• Componente open-source de tu stack con CVE crítico y exploitation activa.

Detección · SPL

index=sysmon (SHA256 IN ("HASH1","HASH2","HASH3")
              OR Image="*nombre-vendor-comprometido*")
| stats count earliest(_time) as first_seen by host Image SHA256
| sort first_seen

index=firewall OR index=dns OR index=proxy
  (dest_ip IN ("IOC_IP1","IOC_IP2") OR query="*IOC_DOMAIN*" OR dest_domain="*IOC_DOMAIN*")
| stats count values(src_ip) as origenes earliest(_time) as first_seen by dest

index=sysmon EventCode=1 Image="*nombre-software-confiable*"
  (CommandLine="*powershell*" OR CommandLine="*cmd*"
   OR CommandLine="*wmic*" OR CommandLine="*-enc*")
| table _time host Image CommandLine ParentImage

Contención

• Inventariar dónde está instalado el componente comprometido (CMDB, EDR, gestión de parches).
• Aislar hosts con la versión vulnerable mientras se confirma exposición.
• Bloquear IoCs en firewall, proxy, EDR, DNS.
• Aplicar parche/mitigación del vendor — o desinstalar si no hay parche.
• Hunting retrospectivo: ¿hubo actividad sospechosa desde la fecha de la primera versión troyanizada?
• Coordinar con el vendor y con CERT nacional si el alcance lo justifica.