snaffcon/snaffleruna herramienta para pentesters para ayudar a encontrar deliciosos caramelos, por @l0ss y @Sh3r4 ( Twitter: @/mikeloss y @/sh3r4_hax )
Snaffler es una herramienta para pentesters y red teamers que ayuda a encontrar deliciosas agujas de caramelo (credenciales principalmente, pero es flexible) en un montón de horribles y aburridos pajares (un entorno masivo de Windows/AD).
También podría ser útil para otras personas que hacen otras cosas, pero explícitamente NO está pensada para ser una herramienta de "auditoría".
Uf, está bien. Pero no somos responsables de los resultados. Escribimos todo esto para ti, pero está bien. No estamos enfadados, solo decepcionados.
snaffler.exe -s -o snaffler.log
En términos generales: obtiene una lista de equipos Windows de Active Directory, luego extiende sus apéndices rastreadores a todos ellos para averiguar cuáles tienen recursos compartidos y si puedes leerlos.
Luego, AÚN MÁS apéndices rastreadores enumeran todos los archivos en esos recursos compartidos y utilizan INTELIGENCIA ARTEFACTUAL APRENDIDA para MÁQUINAS para determinar cuáles podría querer un hacker sucio como tú.
En realidad, no hace nada de ML, porque hacerlo bien requeriría datos de entrenamiento, y eso requeriría una cantidad enorme de tiempo que no tenemos. En su lugar, como todos los buenos proyectos de "ML", simplemente usa un montón de sentencias if y expresiones regulares.
¡Así!
Si "ejecutas literalmente el EXE en una máquina unida al dominio en el contexto de un usuario de dominio" (como se instruyó a la gente que hiciera con Grouper2, justo antes de que lo ejecutaran con todos los modificadores verbose/debug activados, gritando varios cientos de megabytes de trazas de pila), básicamente no hará nada. Esta es nuestra idea de una bromaTM para aquellos que no leen los archivos README, porque somos monstruos.
SIN EMBARGO... si agregas los conjuros correctos, activará el mencionado I.A.A.M. y las rutas de archivos donde puede haber caramelo se revelarán.
Los conjuros clave son:
-o Habilita la salida de resultados a un archivo. Probablemente quieras esto si no estás usando -s. Por ejemplo, -o C:\users\cosa\snaffler.log
-s Habilita la salida de resultados a la salida estándar tan pronto como se encuentren. Probablemente quieras esto si no estás usando -o.
-v Controla el nivel de verbosidad, las opciones son Trace (más verboso), Debug (menos verboso, menos bichos), Info (aún menos verboso, predeterminado) y Data (solo resultados). Por ejemplo, -v debug
-m Habilita y asigna un directorio de salida para que Snaffler copie automáticamente (o "Snaffle", si se quiere) cualquier archivo encontrado que le guste.
-l Tamaño máximo de archivos (en bytes) a "Snafflear". El valor predeterminado es 10000000, que es aproximadamente 10 MB.
-i Deshabilita el descubrimiento de equipos y recursos compartidos, requiere una ruta a un directorio en el que realizar el descubrimiento de archivos.
-n Deshabilita el descubrimiento de equipos, toma una lista separada por comas de hosts o un archivo de entrada para realizar el descubrimiento de recursos compartidos y archivos. Nota: si se proporciona un archivo, la entrada debe ser una ruta, por ejemplo, C:\targets.txt o .\targets.txt.
-y Formatea la salida en TSV.
-b Omite las reglas LAIM que encontrarán cosas menos interesantes, ajústalo con un número entre 0 y 3.
-f Limita a Snaffler a encontrar recursos compartidos de archivos mediante DFS (Sistema de Archivos Distribuido); esto debería ser bastante más sigiloso que el valor predeterminado, aunque cubre los recursos compartidos más grandes en muchas organizaciones.
-a Omite la enumeración de archivos, solo te da una lista de recursos compartidos legibles en los hosts objetivo.
-u Hace que Snaffler obtenga una lista de nombres de cuentas de AD, elija los que parezcan más interesantes y luego los use en una regla de búsqueda.
-d Dominio para buscar equipos en los que buscar recursos compartidos para buscar archivos. Fácil.
-c Controlador de dominio para consultar la lista de equipos del dominio.
-r Tamaño máximo de archivo (en bytes) para buscar dentro de cadenas interesantes. El valor predeterminado es 500k.
-j Cuántos bytes de contexto a cada lado de las cadenas encontradas en los archivos mostrar, por ejemplo, -j 200
-z Ruta a un archivo de configuración que define todo lo anterior, ¡y mucho más! Consulta abajo para más detalles. Dale -z generate para generar un archivo de configuración de muestra llamado .\default.toml.
-t Tipo de registro que deseas generar. Las opciones admitidas actualmente son plain y JSON. El valor predeterminado es plain.
-x Número máximo de hilos a usar. No lo pongas por debajo de 4 o se romperá.
-p Ruta a un directorio lleno de archivos de reglas en formato .toml. Snaffler cargará todos ellos en lugar del conjunto de reglas predeterminado.
Con suerte, este ejemplo anotado ayudará:
Esta entrada de registro debe leerse aproximadamente de izquierda a derecha como:
... y el resto de la línea (en gris) es un pequeño fragmento de contexto del archivo donde se encontró la coincidencia.
En este caso, hemos encontrado valores de validationKey y decryptionKey de ASP.NET, lo que podría permitirnos RCE en la aplicación web mediante algún truco de deserialización. ¡Hurra!
Nota: después de que se tomó esta captura de pantalla, Sh3r4 agregó una función para anteponer el usuario actual y el nombre de host a cada línea. No quiero repetir la captura de pantalla.
Cada método mágico de búsqueda de archivos de I.A.A.M. hace cosas como:
Buscar por coincidencia exacta de extensión de archivo, lo que significa que cualquier archivo con una extensión que coincida con la lista de palabras relevante será devuelto. Esto está pensado para extensiones de archivo que casi siempre contienen caramelo, por ejemplo, .kdbx, .vmdk, .ppk, etc.
Buscar por coincidencia exacta de nombre de archivo (sin distinción de mayúsculas/minúsculas). Esto está pensado para nombres de archivo que casi siempre contienen caramelo, por ejemplo, id_rsa, shadow, NTDS.DIT, etc.
Buscar por coincidencia exacta de extensión de archivo (otra lista de palabras) SEGUIDA de 'grepear' el contenido de cualquier archivo coincidente en busca de ciertas palabras clave (otra lista de palabras más). Esto está pensado para extensiones de archivo que a veces contienen caramelo pero donde sabes que probablemente haya mucha paja que examinar. Por ejemplo, web.config a veces contiene credenciales de base de datos, pero también suele contener tonterías de configuración de IIS aburridas y sin contraseñas. Esto encontrará (por ejemplo) cualquier cosa que termine en .config, luego la grepeará en busca de cadenas que incluyan, entre otras: connectionString, password, , etc.
Snaffler utiliza un sistema de "clasificadores", cada uno de los cuales examina recursos compartidos, carpetas, archivos o contenidos de archivos, pasando algunos elementos al siguiente clasificador y descartando otros. Cada clasificador utiliza un conjunto de reglas para decidir qué hacer con los elementos que clasifica.
Estas reglas pueden ser muy simples, por ejemplo, "si la extensión de un archivo es .kdbx, dímelo", o "si una ruta contiene windows\sxs, deja de mirar subdirectorios y archivos dentro de esa ruta".
Las reglas también pueden usar expresiones regulares, lo que permite un reconocimiento de patrones relativamente sofisticado. Esto es particularmente útil al examinar el contenido de archivos, aunque se debe tener cuidado para evitar expresiones regulares con un impacto significativo en el rendimiento. En entornos grandes, estas reglas pueden verificarse literalmente millones de veces, por lo que los problemas menores de rendimiento pueden amplificarse significativamente.
El verdadero poder está en la capacidad de Snaffler para encadenar múltiples reglas, e incluso crear cadenas ramificadas. Esto nos permite usar reglas "baratas" como verificar nombres y extensiones de archivos para decidir cuándo usar reglas "costosas" como ejecutar expresiones regulares en el contenido de archivos, analizar certificados para ver si contienen claves privadas, etc. Esto es lo que permite a Snaffler lograr una inspección bastante profunda de archivos cuando es necesario, mientras que también es sorprendentemente rápido para una herramienta escrita en un lenguaje de alto nivel como C#.
Por ejemplo, un conjunto de reglas muy simple podría contener:
.dmp y snafflearlos.ps1 y envía todos los archivos coincidentes tanto a la segunda como a la tercera regla.cmd.exe, como podrían encontrarse en archivos .bat o .cmd, ya que también se usan comúnmente dentro de scripts de PowerShell.Este enfoque también nos permite mantener un conjunto de reglas relativamente manejable y legible, y también facilita mucho que el usuario final (tú) personalice los valores predeterminados o desarrolle sus propios conjuntos de reglas.
Tienes razón, lo era.
Snaffler viene con un conjunto de reglas predeterminadas integradas en el .exe. Puedes verlas en ./Snaffler/SnaffRules/DefaultRules.
No hay problema, bicho raro enorme. Tienes 2 opciones.
DefaultRules, luego compilar un nuevo Snaffler. Los archivos .toml en ese directorio se integrarán en el .exe como recursos y se cargarán en tiempo de ejecución siempre que no especifiques otras reglas para usar.-p .\ruta\a\reglas. Snaffler analizará todos los archivos .toml en ese directorio y usará el conjunto de reglas resultante. Esto también funcionará si los tienes todos en un solo archivo .toml grande.Aquí hay algunos ejemplos anotados que probablemente ayudarán a explicar las cosas mejor. Si esto parece muy difícil, puedes usar nuestras reglas y probablemente encontrarán cosas buenas.
Este es un ejemplo de una regla que hará que Snaffler ignore todos los archivos y subdirectorios debajo de un directorio con un nombre determinado.```toml [[ClassifierRules]] EnumerationScope = "DirectoryEnumeration" # This defines which phase of the discovery process we're going to apply the rule. # In this case, we're looking at directories. # Valid values include ShareEnumeration, DirectoryEnumeration, FileEnumeration, ContentsEnumeration RuleName = "DiscardLargeFalsePosDirs" # This can be whatever you want. We've been following a rough naming scheme, but you can call it "Stinky" if you want. ¯_(ツ)_/¯ MatchAction = "Discard"# What to do with things that match the rule. In this case, we want to discard anything that matches this rule. # Valid options include: Snaffle (keep), Discard, Relay (example of this below), and CheckForKeys (example below) Description = "File paths that will be skipped entirely." # Not used in the code, just a place for notes really. MatchLocation = "FilePath" # What part of the file/dir/share to look at to check for a match. In this case we're looking at the whole path. # Valid options include: ShareName, FilePath, FileName, FileExtension, FileContentAsString, FileContentAsBytes, # although obviously not all of these will apply in all EnumerationScopes. WordListType = "Contains" # What matching logic to apply, valid options are: Exact, Contains, EndsWith, StartsWith, or Regex. # Under the hood these all get turned into regexen one way or another. MatchLength = 0 WordList = [
"\\\\puppet\\\\share\\\\doc",
"\\\\lib\\\\ruby",
"\\\\lib\\\\site-packages",
"\\\\usr\\\\share\\\\doc",
"node_modules",
"vendor\\\\bundle",
"vendor\\\\cache",
"\\\\doc\\\\openssl",
"Anaconda3\\\\Lib\\\\test",
"WindowsPowerShell\\\\Modules",
"Python27\\\\Lib"
] Triage = "Green" # If we find a match, what severity rating should we give it. Valid values are Black, Red, Yellow, Green. This value is ignored for Discard MatchActions.
Esta regla, por otro lado, examinará las extensiones de archivo y descartará inmediatamente cualquier que no nos guste.
En este caso, estoy principalmente descartando fuentes, imágenes, CSS, etc.```toml
[[ClassifierRules]]
EnumerationScope = "FileEnumeration" # We're looking at the actual files, not the shares or dirs or whatever.
RuleName = "DiscardExtExact" # just a name
MatchAction = "Discard" # We're discarding these
MatchLocation = "FileExtension" # This time we're only looking at the file extension part of the file's name.
WordListType = "Exact" # and we only want exact matches.
WordList = [".bmp", ".eps", ".gif", ".ico", ".jfi", ".jfif", ".jif", ".jpe", ".jpeg", ".jpg", ".png", ".psd", ".svg", ".tif", ".tiff", ".webp", ".xcf", ".ttf", ".otf", ".lock", ".css", ".less"] # list of file extensions.
Aquí tienes un ejemplo de una regla realmente simple para cosas que nos gustan y queremos conservar.```toml [[ClassifierRules]] EnumerationScope = "FileEnumeration" # Still looking at files RuleName = "KeepExtExactBlack" # Just a name MatchAction = "Snaffle" # This time we are 'snaffling' these. This usually just means send it to the output, # but if you turn on the appropriate option it will also grab a copy. MatchLocation = "FileExtension" # We're looking at file extensions again WordListType = "Exact" # With Exact Matches WordList = [".kdbx", ".kdb", ".ppk", ".vmdk", ".vhdx", ".ova", ".ovf", ".psafe3", ".cscfg", ".kwallet", ".tblk", ".ovpn", ".mdf", ".sdf", ".sqldump"] # and a bunch of fun file extensions. Triage = "Black" # these are all big wins if we find them, so we're giving them the most severe rating.
Este es básicamente el mismo, pero estamos viendo el nombre completo del archivo. ¡Simple!```toml
[[ClassifierRules]]
EnumerationScope = "FileEnumeration"
RuleName = "KeepFilenameExactBlack"
MatchAction = "Snaffle"
MatchLocation = "FileName"
WordListType = "Exact"
WordList = ["id_rsa", "id_dsa", "NTDS.DIT", "shadow", "pwd.db", "passwd"]
Triage = "Black"
Este es un poco ingenioso, échale un vistazo...```toml [[ClassifierRules]] EnumerationScope = "FileEnumeration" # we're looking for files... RuleName = "KeepCertContainsPrivKeyRed" MatchLocation = "FileExtension" # specifically, ones with certain file extensions... WordListType = "Exact" WordList = [".der", ".pfx"] # specifically these ones... MatchAction = "CheckForKeys" # and any that we find, we're going to parse them as x509 certs, and see if the file includes a private key! Triage = "Red" # cert files aren't very sexy, and you'll get huge numbers of them in most wintel environments, but this check gives us a way better SNR!
Bien, aquí es donde entra lo potente. Tenemos un par de reglas en cadena aquí.
Los archivos con extensiones que coincidan con la primera regla serán enviados a la segunda regla, que hará un "grep" (es decir, String.Contains()) para buscar contenido en una lista de palabras específica.
Puedes encadenarlas todo lo que quieras, aunque imagino que empezarás a ver problemas de rendimiento si te vuelves demasiado "inception-y" con ello.```toml
[[ClassifierRules]]
EnumerationScope = "FileEnumeration" # this one looks at files...
RuleName = "ConfigGrepExtExact"
MatchLocation = "FileExtension" # specifically the extensions...
WordListType = "Exact"
WordList = [".yaml", ".xml", ".json", ".config", ".ini", ".inf", ".cnf", ".conf"] # these ones.
MatchAction = "Relay" # Then any files that match are handed downstream...
RelayTargets = ["KeepConfigGrepContainsRed"] # To the rule with this RuleName! This can also be an array of RuleNames if you want to get real wild and start writing branching rulesets.
[[ClassifierRules]]
RuleName = "KeepConfigGrepContainsRed" # Anyway, this is the target rule. Following a naming convention really helps to make sure you're using the right targets.
EnumerationScope = "ContentsEnumeration" # this one looks at file content!
MatchAction = "Snaffle" # it keeps files that match
MatchLocation = "FileContentAsString" # it's looking at the contents as a string (rather than a byte array)
WordListType = "Contains" # it's using simple matching
WordList = ["password=", " connectionString=\"", "sqlConnectionString=\"", "validationKey=", "decryptionKey=", "NVRAM config last updated"]
Triage = "Red"
Con suerte, esto transmite la idea. Recomiendo tomar algunas de las reglas predeterminadas y modificarlas hasta que sientas que las dominas bien.
Mucha gente quería la capacidad de inspeccionar formatos de archivo que no fueran solo texto plano, como documentos de Word, PDFs, .eml, etc. Desafortunadamente, la librería más fácil para implementar esa funcionalidad aumentó el tamaño final del archivo Snaffler.exe en aproximadamente un 1200%, lo que fue malo para muchas de las técnicas populares de ejecución en memoria que tenían límites superiores en el tamaño de archivo con el que podían usarse.
La solución fue UltraSnaffler, que es simplemente un segundo archivo .sln que habilita la librería requerida y el código relevante. Compila UltraSnaffler.sln, obtén UltraSnaffler.
ADVERTENCIA: Las reglas predeterminadas de Snaffler no incluyen ninguna que inspeccione documentos de Office o PDFs, porque nos resultó realmente difícil escribir alguna que no tomara años para completar una ejecución en un entorno corporativo típico. Ten cuidado, inspeccionar estos documentos es mucho más lento que inspeccionar los buenos y viejos archivos de texto, y un entorno típico tendrá una montaña absoluta de documentos de Office y PDFs de bajo valor.
Esto es realmente genial en mi opinión.
Si agregas -z generate al final de una línea de comandos de Snaffler, Snaffler serializará el objeto de configuración (incluyendo cualquier aspecto de la configuración que haya sido establecido por tus argumentos) en un archivo de configuración .toml, que luego puedes editar manualmente con bastante facilidad (o no) y luego reutilizar a tu antojo.
Por ejemplo, si haces:
Snaffler.exe -s -o C:\mydir\snaffler.log -v trace -i \\host.lol.domain\share -p C:\users\someguy\myrules -z generate
Snaffler analizará todos tus muchos argumentos, los convertirá en un objeto de configuración, serializará ese objeto de configuración en el siguiente archivo de configuración .toml:```toml
PathTargets = ["\\host.lol.domain\share"]
ComputerTargetsLdapFilter = "(objectClass=computer)"
ScanSysvol = true
ScanNetlogon = true
ScanFoundShares = true
InterestLevel = 0
DfsOnly = false
DfsShareDiscovery = false
DfsNamespacePaths = []
CurrentUser = "l0sslab\l0ss"
RuleDir = "C:\users\someguy\myrules"
MaxThreads = 60
ShareThreads = 20
TreeThreads = 20
FileThreads = 20
MaxFileQueue = 200000
MaxTreeQueue = 0
MaxShareQueue = 0
LogToFile = true
LogFilePath = "C:\mydir\snaffler.log"
LogType = "Plain"
LogTSV = false
Separator = 32
LogToConsole = true
LogLevelString = "trace"
ShareFinderEnabled = false
LogDeniedShares = false
DomainUserRules = false
DomainUserMinLen = 6
DomainUserNameFormats = ["sAMAccountName"]
DomainUserMatchStrings = ["sql", "svc", "service", "backup", "ccm", "scom", "opsmgr", "adm", "adcs", "MSOL", "adsync", "thycotic", "secretserver", "cyberark", "configmgr"]
DomainUsersWordlistRules = ["KeepConfigRegexRed"]
MaxSizeToGrep = 1000000
Snaffle = false
MaxSizeToSnaffle = 10000000
MatchContextBytes = 200
Puede notar que hay muchos elementos aquí para los que no pasó argumentos. Esos valores son los elementos de configuración predeterminados, algunos de los cuales solo se pueden editar fácilmente en el código fuente o mediante un archivo de configuración, generalmente porque no pareció valer la pena agregar un argumento para ellos.
## Esto apesta, ¿tienes planes para que apeste menos?
No, no lo hace, tú apestas.
Además, sí, los tenemos.
También vamos a:
- Agregar análisis de archivos comprimidos, idealmente tratándolos como otro directorio más para recorrer en busca de tesoros.
- Seguir refinando las reglas y las expresiones regulares. **¡Más palabras para las listas de palabras! `string[]`s para el trono `string`!**
## ¿De quién robaste código?
Los fragmentos de enumeración de recursos compartidos fueron 'snaffled' (¿vieron lo que hice ahí?) de SharpShares, que fue escrito por el extremadamente útil Dwight Hohnstein. (https://github.com/djhohnstein/SharpShares/)
El perfil de GitHub de Dwight es como ese pasillo trasero increíble de una ferretería que tiene un montón de herramientas que te hacen decir "oh, hombre, no puedo esperar a tener una excusa para probar esta de verdad..." y definitivamente deberías echarle un vistazo.
Aunque no se tomó código (principalmente porque es Ruby lol), sí robamos un montón de ideas ingeniosas de `plunder2` (http://joshstone.us/plunder2/)
Las listas de palabras también se seleccionaron de las encontradas en otras herramientas similares como trufflehog, shhgit, gitrobber y graudit.
## ¿Es seguro para OPSEC? (Lo que sea que eso signifique)
Pffft, no. Es ruidoso como el carajo.
Mira, pongámoslo así... Si es el tipo de entorno en el que te sentirías seguro ejecutando BloodHound en su modo predeterminado, entonces uhhh, sí, hombre... Es realmente sigiloso.
## ¿No pensé que usabas esto en trabajos de equipo rojo?
*suspiro*
OK, te daré la respuesta real.
En modo predeterminado, Snaffler se parece muchísimo a SharpHound, en muchos aspectos. Habla un montón de LDAP con AD, luego sale e intenta hablar SMB con cada máquina Windows del dominio. Este tipo de comportamiento tiene casi garantizado que te atrapen en una organización que tenga sus cosas aunque sea mínimamente organizadas.
SIN EMBARGO...
Las opciones más específicas de Snaffler (especialmente `-i`) tienen *muchas* menos probabilidades de activar detecciones.
Soy particularmente fan de ejecutar `Snaffler.exe -s -i C:\` en un servidor o estación de trabajo recién comprometido, y no he visto que este comportamiento sea detectado.
Todavía.
## ¿Cómo puedo ayudar u obtener ayuda?
Si quieres discutir a través de Slack, puedes contactarnos (@l0ss o @Sh3r4) en el Slack de BloodHound, al que se puede acceder en https://bloodhoundgang.herokuapp.com/, o chatear con un grupo de colaboradores en el canal #snaffler.
También puedes contactarnos en Twitter - @mikeloss y @sh3r4_hax
De lo contrario, abre un issue; lo intentaremos.
PRIVATE KEYBuscar por coincidencia parcial de nombre de archivo (más listas de palabras, oh Dios). Esto está pensado principalmente para encontrar "Archivo de Contraseñas de Jeff 2019 (Copia).docx" o "Diseño del Sistema de Gestión de Acceso Privilegiado - Tal cual se construyó.docx" o lo que sea, coincidiendo con cualquier archivo cuyo nombre contenga las subcadenas passw, entrega, secreto, seguro, as-built, etc.
También hay listas de omisión para saltar todos los archivos con ciertas extensiones, o cualquier archivo cuya ruta contenga una cadena determinada.