snaffcon/snaffleruno strumento per pentester per aiutare a trovare caramelle deliziose, di @l0ss e @Sh3r4 ( Twitter: @/mikeloss e @/sh3r4_hax )
Snaffler è uno strumento per penetration tester e red teamer per aiutare a trovare deliziosi aghi di caramella (principalmente credenziali, ma è flessibile) in un mucchio di orribili e noiosi pagliai (un enorme ambiente Windows/AD).
Potrebbe anche essere utile per altre persone che fanno altre cose, ma non è esplicitamente concepito come strumento di "audit".
Uff, va bene. Ma non siamo responsabili dei risultati. Abbiamo scritto tutta questa altra roba per te, ma va bene così. Non siamo arrabbiati, solo delusi.
snaffler.exe -s -o snaffler.log
In parole povere - ottiene un elenco di computer Windows da Active Directory, poi estende le sue appendici annusatrici a tutti loro per capire quali hanno condivisioni file e se puoi leggerle.
Poi ANCORA PIÙ appendici annusatrici enumerano tutti i file in quelle condivisioni e usano L'INTELIGENZA ARTEFATTUALE APPRESA per MACCHINE per capire quali potrebbero interessare a un lurido piccolo hacker come te.
In realtà non fa nulla di ML, perché farlo bene richiederebbe dati di addestramento, e questo richiederebbe un'enorme quantità di tempo che non abbiamo. Invece, come tutti i buoni progetti "ML", usa solo un sacco di istruzioni if e regex.
Così!
Se "semplicemente esegui l'EXE su una macchina joined al dominio nel contesto di un utente di dominio" (come è stato detto alla gente di fare con Grouper2, subito prima che lo eseguissero con tutti gli switch verbose/debug attivi in modo che urlassero diverse centinaia di megabyte di stack trace) non farà praticamente nulla. Questa è la nostra idea di scherzoTM per chi non legge i file README, perché siamo mostri.
TUTTAVIA... se aggiungi le giuste formule magiche, abiliterà il suddetto L.A.I.M. e i percorsi dei file dove potrebbe esserci caramella verranno fuori.
Le formule magiche chiave sono:
-o Abilita l'output dei risultati su file. Probabilmente lo vuoi se non stai usando -s. Es. -o C:\users\cosa\snaffler.log
-s Abilita l'output dei risultati su stdout appena vengono trovati. Probabilmente lo vuoi se non stai usando -o.
-v Controlla il livello di verbosità, le opzioni sono Trace (più verboso), Degub (meno verboso, meno gub), Info (ancora meno verboso, predefinito) e Data (solo risultati). Es. -v debug
-m Abilita e assegna una directory di output in cui snaffler copierà automaticamente (o Snafflerà... se vuoi) qualsiasi file trovato che gli piace.
-l Dimensione massima dei file (in byte) da Snafflare. Predefinito a 10000000, che è circa 10MB.
-i Disabilita la scoperta di computer e condivisioni, richiede un percorso a una directory in cui eseguire la scoperta dei file.
-n Disabilita la scoperta dei computer, accetta un elenco separato da virgole di host o un file di input per eseguire la scoperta di condivisioni e file. Nota: se si fornisce un file, l'input deve essere un percorso, ad esempio C:\targets.txt o .\targets.txt.
-y Formatta l'output in TSV.
-b Salta le regole LAIM che troveranno roba meno interessante, sintonizzalo con un numero tra 0 e 3.
-f Limita Snaffler alla ricerca di condivisioni file tramite DFS (Distributed File System) - questo dovrebbe essere molto più furtivo rispetto al predefinito coprendo comunque le condivisioni file più grandi in molte organizzazioni.
-a Salta l'enumerazione dei file, fornisce solo un elenco di condivisioni listabili sugli host target.
-u Fa sì che Snaffler recuperi un elenco di nomi account da AD, scelga quelli più interessanti e li usi in una regola di ricerca.
-d Dominio in cui cercare computer per cercare condivisioni in cui cercare file. Facile.
-c Controller di dominio da interrogare per l'elenco dei computer del dominio.
-r Dimensione massima del file (in byte) da ispezionare internamente per stringhe interessanti. Predefinito a 500k.
-j Quanti byte di contesto mostrare ai lati delle stringhe trovate nei file, es. -j 200
-z Percorso a un file di configurazione che definisce tutto quanto sopra, e molto altro! Vedi sotto per maggiori dettagli. Dagli -z generate per generare un file di configurazione di esempio chiamato .\default.toml.
-t Tipo di log da produrre. Opzioni attualmente supportate: plain e JSON. Predefinito plain.
-x Numero massimo di thread da usare. Non impostarlo sotto 4 o si romperà tutto.
-p Percorso a una directory piena di file di regole in formato .toml. Snaffler caricherà tutti questi al posto del ruleset predefinito.
Speriamo che questo esempio annotato possa aiutare:
Questa voce di log dovrebbe essere letta approssimativamente da sinistra a destra come:
... e il resto della riga (in grigio) è un piccolo snippet di contesto dal file dove è stato trovato il match.
In questo caso abbiamo trovato i valori validationKey e decryptionKey di ASP.NET, che potrebbero permetterci di eseguire RCE sull'app web tramite qualche hack di deserializzazione. Evviva!
Nota: dopo che questo screenshot è stato fatto, Sh3r4 ha aggiunto una cosa per anteporre l'utente corrente e il nome host a ogni riga. Ma non voglio rifare lo screenshot.
Ogni magico metodo di ricerca file L.A.I.M. fa cose come:
Cercare per corrispondenza esatta di estensione file, per cui qualsiasi file con un'estensione che corrisponde alla wordlist pertinente verrà restituito. Questo è pensato per estensioni di file che contengono quasi sempre caramella, es. .kdbx, .vmdk, .ppk, ecc.
Cercare per corrispondenza esatta del nome file (senza distinzione tra maiuscole/minuscole). Questo è pensato per nomi di file che contengono quasi sempre caramella, es. id_rsa, shadow, NTDS.DIT, ecc.
Cercare per corrispondenza esatta di estensione file (un'altra wordlist) SEGUITA dal 'grep' del contenuto di qualsiasi file corrispondente per certe parole chiave (un'altra ancora wordlist). Questo è pensato per estensioni di file che a volte contengono caramella ma dove sai che probabilmente c'è molta pula da setacciare. Ad esempio, web.config a volte contiene credenziali di database, ma spesso contiene anche noioso nonsense di configurazione IIS e nessuna password. Questo troverà (per esempio) qualsiasi cosa che finisce in .config, poi farà grep attraverso di esso per stringhe incluse ma non limitate a: connectionString, password, , ecc.
Snaffler utilizza un sistema di "classificatori" (classifiers), ognuno dei quali esamina condivisioni, cartelle, file o contenuti di file, passando alcuni elementi a valle al classificatore successivo e scartandone altri. Ogni classificatore usa un insieme di regole per decidere cosa fare con gli elementi che classifica.
Queste regole possono essere molto semplici, es. "se un file ha estensione .kdbx, segnalamelo", o "se un percorso contiene windows\sxs allora smetti di guardare le sottodirectory e i file al suo interno".
Le regole possono anche usare espressioni regolari, che permettono pattern matching relativamente sofisticato. Questo è particolarmente utile quando si esaminano i contenuti dei file, anche se bisogna fare attenzione a evitare regex con un impatto significativo sulle prestazioni. In ambienti grandi queste regole potrebbero essere controllate letteralmente milioni di volte, quindi piccoli problemi di performance possono essere amplificati significativamente.
Il vero potere di Snaffler è nella sua capacità di concatenare più regole insieme, e persino creare rami di catene. Questo ci permette di usare regole "economiche" come controllare nomi di file ed estensioni per decidere quando usare regole "costose" come eseguire regex sul contenuto dei file, analizzare certificati per vedere se contengono chiavi private, ecc. Questo è ciò che permette a Snaffler di ottenere un'ispezione abbastanza approfondita dei file dove necessario, pur essendo sorprendentemente veloce per uno strumento scritto in un linguaggio di alto livello come C#.
Ad esempio, un ruleset molto semplice potrebbe contenere:
.dmp e snafflarli.ps1, e invia tutti i file corrispondenti sia alla seconda che alla terza regola.cmd.exe, come si potrebbe trovare in file .bat o .cmd, dato che sono anche comunemente usati all'interno di script PowerShell.Questo approccio ci permette anche di mantenere un ruleset relativamente gestibile e leggibile, e rende anche molto più facile per l'utente finale (tu) personalizzare le impostazioni predefinite o sviluppare i propri ruleset.
Hai ragione, lo era.
Snaffler viene fornito con un set di regole predefinite integrate nell'.exe. Puoi vederle in ./Snaffler/SnaffRules/DefaultRules.
Nessun problema, strano essere. Hai 2 opzioni.
DefaultRules, quindi compilare un nuovo Snaffler. I file .toml in quella directory verranno incorporati nell'.exe come risorse e caricati all'avvio ogni volta che non specifichi altre regole da usare.-p .\path\to\rules. Snaffler analizzerà tutti i file .toml in quella directory e userà il ruleset risultante. Funzionerà anche se li hai tutti in un unico grande file .toml.Ecco alcuni esempi annotati che speriamo possano aiutare a spiegare meglio le cose. Se sembra molto difficile, puoi semplicemente usare le nostre regole e probabilmente troveranno roba interessante.
Questo è un esempio di regola che farà sì che Snaffler ignori tutti i file e le sottodirectory al di sotto di una directory con un certo nome.```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.
Questa regola invece guarderà le estensioni dei file e scarterà immediatamente quelle che non ci piacciono.
In questo caso scarto principalmente font, immagini, CSS, ecc.```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.
Ecco un esempio di una regola davvero semplice per le cose che ci piacciono e che vogliamo tenere.```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.
Questo è fondamentalmente lo stesso, ma stiamo guardando l'intero nome del file. Semplice!```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"
Questo è un po' ingegnoso, dai un'occhiata...```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!
OK, ecco dove entrano in gioco le cose potenti. Abbiamo una coppia di regole in una catena qui.
I file con estensioni che corrispondono alla prima regola verranno inviati alla seconda regola, che li "grep" (cioè String.Contains()) per trovare elementi in una wordlist specifica.
Puoi concatenarle quanto vuoi, anche se immagino che inizierai a vedere alcuni problemi di prestazioni se diventi troppo "inception-y" con la cosa.```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"
Spero che questo renda l'idea. Ti consiglio di prendere alcune delle regole predefinite e di sperimentare con esse finché non ti senti a tuo agio.
Molte persone volevano la possibilità di esaminare formati di file che non fossero solo testo semplice, come documenti Word, PDF, .eml, ecc. Purtroppo, la libreria più semplice per implementare quella funzionalità ha fatto aumentare la dimensione finale del file di Snaffler.exe di circa il 1200%, il che è stato un problema per molte popolari tecniche di esecuzione in memoria che avevano limiti superiori sulla dimensione del file con cui potevano essere utilizzate.
La soluzione è stata UltraSnaffler, che è semplicemente un secondo file .sln che abilita la libreria richiesta e il codice pertinente. Compila UltraSnaffler.sln, ottieni UltraSnaffler.
ATTENZIONE: le regole predefinite di Snaffler non includono alcuna che esamini i documenti Office o i PDF, perché abbiamo trovato molto difficile scriverne una che non richiedesse anni per completare un'esecuzione in un tipico ambiente aziendale. Attenzione, esaminare questi documenti è molto più lento che esaminare i buoni vecchi file di testo, e un tipico ambiente avrà una montagna di documenti Office e PDF di scarso valore.
Questo è davvero figo secondo me.
Se aggiungi -z generate alla fine di una riga di comando di Snaffler, Snaffler serializzerà l'oggetto di configurazione (incluse tutte le impostazioni della configurazione specificate dai tuoi argomenti) in un file di configurazione .toml, che potrai quindi modificare manualmente abbastanza facilmente (o meno) e riutilizzare a tuo piacimento.
Ad esempio, se esegui:
Snaffler.exe -s -o C:\mydir\snaffler.log -v trace -i \\host.lol.domain\share -p C:\users\someguy\myrules -z generate
Snaffler analizzerà tutti i tuoi molti, molti argomenti, li trasformerà in un oggetto di configurazione, serializzerà quell'oggetto di configurazione nel seguente file di configurazione .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
Potresti notare che ci sono molti elementi qui per cui non hai passato argomenti. Quei valori sono gli elementi di configurazione predefiniti, alcuni dei quali possono essere modificati facilmente solo nel codice sorgente o tramite un file di configurazione, di solito perché non sembrava valesse la pena aggiungere un argomento per loro.
## Fa schifo, avete piani per farlo schifare meno?
No, non fa schifo, fai schifo tu.
Inoltre, sì, lo facciamo.
Abbiamo anche intenzione di:
- Aggiungere il parsing dei file di archivio, idealmente trattandoli come un'altra directory da attraversare in cerca di cose interessanti.
- Continuare a perfezionare le regole e le regex. **Altre parole per le wordlist! `string[]` per il trono di `string`!**
## Da chi hai rubato il codice?
I bit di enumerazione delle condivisioni sono stati 'snaffled' (vedi cosa ho fatto lì?) da SharpShares, scritto dall'estremamente utile Dwight Hohnstein. (https://github.com/djhohnstein/SharpShares/)
Il profilo GitHub di Dwight è come quel fantastico corridoio sul retro di un negozio di ferramenta che ha un sacco di strumenti che ti fanno dire 'oh cavolo, non vedo l'ora di avere una scusa per provare questo per davvero...' e dovresti assolutamente dargli un'occhiata.
Anche se nessun codice è stato preso (principalmente perché è Ruby lol) abbiamo rubato un sacco di idee interessanti da `plunder2` (http://joshstone.us/plunder2/)
Le wordlist sono state anche curate da quelle trovate in alcuni altri strumenti simili come trufflehog, shhgit, gitrobber e graudit.
## È OPSEC sicuro? (Qualunque diavolo significhi)
Pffft, no. È rumoroso come la merda.
Guarda, mettiamola così... Se è il tipo di ambiente in cui ti sentiresti sicuro di eseguire BloodHound nella sua modalità predefinita, allora uhhh, sì amico... È davvero stealth.
## Pensavo che usassi questa roba nei lavori di red team?
*sigh*
OK, ti darò la vera risposta.
In modalità predefinita, Snaffler assomiglia moltissimo a SharpHound, in molti modi. Parla un sacco di LDAP con AD, poi esce e prova a parlare SMB a ogni macchina Windows nel dominio. Questo tipo di comportamento è praticamente garantito per farti beccare in un'organizzazione che tiene le cose anche solo un minimo in ordine.
TUTTAVIA...
Le opzioni più mirate di Snaffler (specialmente `-i`) hanno *molto* meno probabilità di innescare rilevamenti.
Sono particolarmente affezionato all'esecuzione di `Snaffler.exe -s -i C:\` su un server o workstation appena compromesso, e non ho mai visto questo comportamento essere rilevato.
Ancora.
## Come posso aiutare o ottenere aiuto?
Se vuoi discutere tramite Slack puoi contattarci (@l0ss o @Sh3r4) sulla Slack di BloodHound, raggiungibile su https://bloodhoundgang.herokuapp.com/, o chattare con un gruppo di contributori nel canale #snaffler.
Puoi anche contattarci su Twitter - @mikeloss e @sh3r4_hax
Altrimenti apri un issue; ci proveremo.
PRIVATE KEYCercare per corrispondenza parziale del nome file (ancora più wordlist). Questo è pensato principalmente per trovare Jeff's Password File 2019 (Copy).docx o Privileged Access Management System Design - As-Built.docx o simili, corrispondendo a qualsiasi file il cui nome contenga le sottostringhe passw, handover, secret, secure, as-built, ecc.
Ci sono anche liste di skip per saltare tutti i file con certe estensioni, o qualsiasi file il cui percorso contenga una stringa data.