snaffcon/snaffleruma ferramenta para pentesters ajudar a encontrar doces deliciosos, por @l0ss e @Sh3r4 ( Twitter: @/mikeloss e @/sh3r4_hax )
# Snaffler
[](https://ko-fi.com/T6T31VEVJ)
## Para que serve?
Snaffler é uma ferramenta para **pentesters** e **red teamers** para ajudar a encontrar deliciosas agulhas de doces (credenciais principalmente, mas é flexível) em um monte de palheiros chatos (um grande ambiente Windows/AD).
Também pode ser útil para outras pessoas fazendo outras coisas, mas explicitamente NÃO é destinado a ser uma ferramenta de "auditoria".
## Não quero ler tudo isso!!!
Ugh, tudo bem. Mas não somos responsáveis pelos resultados. Escrevemos todo esse outro material para você, mas tudo bem. Não estamos bravos, apenas decepcionados.
`snaffler.exe -s -o snaffler.log`
## O que isso faz?
*De modo geral* - ele obtém uma lista de computadores Windows do Active Directory, então espalha seus apêndices farejadores para todos eles para descobrir quais têm compartilhamentos de arquivos e se você pode lê-los.
Então AINDA MAIS apêndices farejadores enumeram todos os arquivos nesses compartilhamentos e usam **L**EARNED **A**RTIFACTUAL **I**NTELLIGENCE for **M**ACHINES para descobrir quais um hacker sujinho como você pode querer.
Na verdade, não faz nada de ML, porque fazer isso direito exigiria dados de treinamento, e isso exigiria uma quantidade enorme de tempo que não temos. Em vez disso, como todos os bons projetos de "ML", ele apenas usa um monte de instruções `if` e regexen.
## Como é que parece?
Assim!
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/5041/8acb1dc4ee910b6f2adf281a4f55572aca3731c4ead5774df7864758a976451a.png">
</p>
## Como eu uso?
Se você "literalmente apenas executar o EXE em uma máquina ingressada no domínio no contexto de um usuário do domínio" (como as pessoas foram instruídas a fazer com o Grouper2, imediatamente antes de executá-lo com todas as opções verbose/debug ativadas, então ele gritou várias centenas de megabytes de stack traces para elas) basicamente não fará nada. Esta é a nossa ideia de uma brincadeira<sup>TM</sup> para pessoas que não leem arquivos README, porque somos monstros.
NO ENTANTO... se você adicionar as encantações corretas, ele habilitará o já mencionado L.A.I.M. e os caminhos de arquivos onde doces podem ser encontrados aparecerão.
As principais encantações são:
`-o` Habilita a saída dos resultados para um arquivo. Você provavelmente quer isso se não estiver usando `-s`. ex: `-o C:\users\thing\snaffler.log`
`-s` Habilita a saída dos resultados para stdout assim que são encontrados. Você provavelmente quer isso se não estiver usando `-o`.
`-v` Controla o nível de verbosidade, as opções são Trace (mais verboso), Degub (menos verboso, menos gubs), Info (ainda menos verboso, padrão) e Data (apenas resultados). ex: `-v debug`
`-m` Habilita e define um diretório de saída para o snaffler automaticamente tirar uma cópia (ou Snaffle... se preferir) de quaisquer arquivos encontrados que ele gostar.
`-l` Tamanho máximo de arquivos (em bytes) para Snaffle. Padrão é 10000000, que é *aproximadamente* 10MB.
`-i` Desabilita a descoberta de computadores e compartilhamentos, requer um caminho para um diretório no qual realizar a descoberta de arquivos.
`-n` Desabilita a descoberta de computadores, aceita uma lista separada por vírgulas de hosts ou arquivo de entrada para realizar descoberta de compartilhamentos e arquivos. Nota: se fornecer um arquivo, a entrada precisa ser um caminho, ex: C:\targets.txt ou .\targets.txt como exemplo.
`-y` Formata a saída em TSV.
`-b` Pula as regras LAIM que encontrarão coisas menos interessantes, ajuste com um número entre 0 e 3.
`-f` Limita o Snaffler a encontrar compartilhamentos de arquivos via DFS (Distributed File System) - isso deve ser um pouco mais sorrateiro que o padrão, enquanto ainda cobre os maiores compartilhamentos de arquivos em muitas organizações.
`-a` Pula a enumeração de arquivos, apenas fornece uma lista de compartilhamentos listáveis nos hosts alvo.
`-u` Faz o Snaffler puxar uma lista de nomes de contas do AD, escolher os que parecem mais interessantes e depois usá-los em uma regra de busca.
`-d` Domínio para pesquisar computadores para pesquisar compartilhamentos para pesquisar arquivos. Fácil.
`-c` Controlador de domínio para consultar a lista de computadores do domínio.
`-r` O tamanho máximo de arquivo (em bytes) para pesquisar dentro em busca de strings interessantes. Padrão é 500k.
`-j` Quantos bytes de contexto de cada lado das strings encontradas em arquivos para mostrar, ex: `-j 200`
`-z` Caminho para um arquivo de configuração que define tudo acima e muito mais! Veja abaixo para mais detalhes. Forneça `-z generate` para gerar um arquivo de configuração de exemplo chamado `.\default.toml`.
`-t` Tipo de log que você gostaria de gerar. Atualmente, as opções suportadas são plain e JSON. Padrão é plain.
`-x` Número máximo de threads a usar. Não defina abaixo de 4 ou algo vai quebrar.
`-p` Caminho para um diretório cheio de regras formatadas em .toml. O Snaffler carregará todos eles no lugar do conjunto de regras padrão.
## O que significa qualquer saída de log?
Esperamos que este exemplo anotado ajude:
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/5041/d840a80c5ba879a8a0aa90af454212220a9705142d166fe5964697c372764b55.png">
</p>
Esta entrada de log deve ser lida aproximadamente da esquerda para a direita como:
* por volta das 7:37
* Snaffler encontrou um arquivo que acha que vale a sua atenção
* classificou como "Red", o segundo nível mais interessante
* correspondeu a uma regra chamada "KeepConfigRegexRed"
* você pode lê-lo, mas não modificá-lo
* a regex exata que foi correspondida é aquela coisa na caixa vermelha
* tem 208kB
* foi modificado pela última vez em 10 de janeiro de 2020 às três e quarenta e cinco da tarde.
* o arquivo pode ser encontrado no caminho em roxo
... e o resto da linha (em cinza) é um pequeno trecho de contexto do arquivo onde a correspondência foi encontrada.
Neste caso, encontramos valores validationKey e decryptionKey do ASP.NET, que podem nos permitir um RCE no aplicativo web através de alguma artimanha de desserialização. Viva!
Nota: depois que esta captura de tela foi feita, Sh3r4 adicionou algo para prefixar o usuário atual e o nome do host a cada linha. Mas não quero refazer a captura de tela.
## Como ele decide quais arquivos são bons e quais são chatos?
### A resposta "tão simples que é quase mentira":
Cada método mágico de localização de arquivos do L.A.I.M. faz coisas como:
* Pesquisa por correspondência exata de extensão de arquivo, o que significa que qualquer arquivo com uma extensão que corresponda à wordlist relevante será retornado. Isso é destinado a **extensões de arquivo** que quase sempre conterão doces, ex: `.kdbx`, `.vmdk`, `.ppk`, etc.
* Pesquisa por correspondência exata de nome de arquivo (case insensitive). Isso é destinado a **nomes de arquivo** que quase sempre conterão doces, ex: `id_rsa`, `shadow`, `NTDS.DIT`, etc.
* Pesquisa por correspondência exata de extensão de arquivo (mais uma wordlist) SEGUIDA por 'grep' do conteúdo de quaisquer arquivos correspondentes por certas palavras-chave (mais outra wordlist). Isso é destinado a extensões de arquivo que **às vezes** contêm doces, mas onde você sabe que provavelmente há muita palha para peneirar. Por exemplo, `web.config` às vezes conterá credenciais de banco de dados, mas também frequentemente conterá configurações chatas do IIS e nenhuma senha. Isso irá (por exemplo) encontrar qualquer coisa terminando em `.config`, depois fará grep por strings incluindo, mas não limitado a: `connectionString`, `password`, `PRIVATE KEY`, etc.
* Pesquisa por correspondência parcial de nome de arquivo (ai meu deus, mais wordlists). Isso é principalmente para encontrar `Jeff's Password File 2019 (Copy).docx` ou `Privileged Access Management System Design - As-Built.docx` ou algo assim, combinando qualquer arquivo onde o nome contenha as substrings `passw`, `handover`, `secret`, `secure`, `as-built`, etc.
* Há também listas de ignorar (skip-lists) para pular todos os arquivos com certas extensões, ou qualquer arquivo com um caminho contendo uma determinada string.
### A resposta verdadeira:
Snaffler usa um sistema de "classificadores", cada um examina compartilhamentos, pastas, arquivos ou conteúdos de arquivos, passando alguns itens adiante para o próximo classificador e descartando outros. Cada classificador usa um conjunto de regras para decidir o que fazer com os itens que classifica.
Essas regras podem ser muito simples, ex: "se a extensão de um arquivo for `.kdbx`, me avise", ou "se um caminho contiver `windows\sxs`, pare de olhar subdiretórios e arquivos dentro desse caminho".
As regras também podem usar expressões regulares, que permitem correspondência de padrões relativamente sofisticada. Isso é particularmente útil ao examinar conteúdos de arquivos, embora se deva tomar cuidado para evitar regexen com impacto significativo no desempenho. Em ambientes grandes, essas regras podem ser verificadas literalmente milhões de vezes, então problemas menores de desempenho podem ser amplificados significativamente.
O verdadeiro poder está na capacidade do Snaffler de encadear várias regras e até criar cadeias ramificadas. Isso nos permite usar regras "baratas", como verificar nomes e extensões de arquivos, para decidir quando usar regras "caras", como executar regexen no conteúdo de arquivos, analisar certificados para ver se contêm chaves privadas, etc. É isso que permite ao Snaffler alcançar uma inspeção bastante profunda de arquivos quando necessário, enquanto também é surpreendentemente rápido para uma ferramenta escrita em uma linguagem de alto nível como C#.
Por exemplo, um conjunto de regras muito simples pode conter:
* uma regra para descartar todos os arquivos com extensões associadas a arquivos de imagem
* uma regra para encontrar todos os arquivos com a extensão `.dmp` e snaffle-os
* uma cadeia de regras onde:
* a primeira regra procura arquivos com a extensão `.ps1` e envia todos os arquivos correspondentes para a segunda e terceira regras.
* a segunda regra examina o interior dos arquivos usando regexen projetados para encontrar credenciais embutidas em código PowerShell.
* a terceira regra examina o interior dos arquivos usando regexen projetados para encontrar credenciais embutidas em comandos `cmd.exe`, como pode ser encontrado em arquivos `.bat` ou `.cmd`, já que estes também são comumente usados em scripts PowerShell.
Essa abordagem também nos permite manter um conjunto de regras relativamente gerenciável e legível, e também torna muito mais fácil para o usuário final (você) personalizar os padrões ou desenvolver seus próprios conjuntos de regras.
### Não quero escrever regras, isso parece difícil e chato.
Você está certo, foi.
O Snaffler vem com um conjunto de regras padrão incorporadas no `.exe`. Você pode vê-las em `./Snaffler/SnaffRules/DefaultRules`.
### Sou um titã poderoso do tédio, um mestre do mundano, desejo escrever meu próprio conjunto de regras.
Sem problema, seu enorme estranho. Você tem 2 opções.
1. Edite ou substitua as regras no diretório `DefaultRules`, depois construa um novo Snaffler. Os arquivos `.toml` nesse diretório serão incorporados no `.exe` como recursos e carregados em tempo de execução sempre que você não especificar outras regras para usar.
2. Crie um diretório e coloque um monte de seus próprios arquivos de regra lá, depois execute Snaffler com `-p .\path\to\rules`. O Snaffler analisará todos os arquivos `.toml` nesse diretório e usará o conjunto de regras resultante. Isso também funcionará se você tiver todos eles em um único arquivo `.toml` grande.
Aqui estão alguns exemplos anotados que esperamos ajudem a explicar melhor as coisas. Se isso parece muito difícil, você pode apenas usar nossas regras e provavelmente elas encontrarão algumas coisas boas para você.
Este é um exemplo de uma regra que fará o Snaffler ignorar todos os arquivos e subdiretórios abaixo de um diretório com um determinado 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 = [
# A list of strings or regex patterns to use to match. If using regex patterns, WordListType must be Regex.
"\\\\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 regra, por outro lado, examinará as extensões de arquivo e descartará imediatamente qualquer uma que não gostarmos.
Neste caso, estou basicamente descartando fontes, imagens, 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.
```
Aqui está um exemplo de uma regra realmente simples para coisas que gostamos e queremos manter.```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 é basicamente o mesmo, mas estamos olhando para o nome completo do arquivo. Simples!```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 é um tanto engenhoso, veja só...```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, aqui é onde as coisas poderosas entram. Temos um par de regras em cadeia aqui.
Arquivos com extensões que correspondem à primeira regra serão enviados para a segunda regra, que fará um "grep" (ou seja, String.Contains()) neles por itens em uma wordlist específica.
Você pode encadear estas regras juntas o quanto quiser, embora eu imagine que você começará a ver alguns problemas de desempenho se ficar muito "inception-y" com isso.```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"
```
Espero que isso transmita a ideia. Recomendo pegar algumas das regras padrão e brincar com elas até sentir que tem um bom entendimento.
## O que é um "UltraSnaffler"???
Muitas pessoas queriam a capacidade de olhar dentro de formatos de arquivo que não eram apenas texto simples, como documentos do Word, PDFs, `.eml`, etc. Infelizmente, a biblioteca mais fácil para implementar essa funcionalidade aumentou o tamanho final do arquivo do `Snaffler.exe` em cerca de 1200%, o que foi uma droga para várias técnicas populares de execução em memória que tinham limites superiores sobre o tamanho de arquivo com que poderiam ser usadas.
A solução foi o UltraSnaffler, que é apenas um segundo arquivo `.sln` que habilita a biblioteca necessária e o código relevante. Compile `UltraSnaffler.sln`, obtenha o UltraSnaffler.
AVISO: As regras padrão do Snaffler não incluem nenhuma que analise documentos do Office ou PDFs, porque achamos muito difícil escrever regras que não levariam *anos* para concluir uma execução em um ambiente corporativo típico. *Fique avisado: analisar esses documentos é muito mais lento do que analisar bons e velhos arquivos de texto, e um ambiente típico terá uma montanha absoluta de documentos do Office e PDFs de baixo valor.*
## Como funciona a questão do arquivo de configuração?
Isso é realmente muito legal, na minha opinião.
Se você adicionar `-z generate` ao final de uma linha de comando do Snaffler, ele serializará o objeto de configuração (incluindo quaisquer aspectos da configuração que foram definidos pelos seus argumentos) em um arquivo de configuração `.toml`, que você poderá editar manualmente com bastante facilidade (ou não) e reutilizar à vontade.
Por exemplo, se você fizer:
`Snaffler.exe -s -o C:\mydir\snaffler.log -v trace -i \\host.lol.domain\share -p C:\users\someguy\myrules -z generate`
O Snaffler analisará todos os seus muitos, muitos argumentos, os transformará em um objeto de configuração e serializará esse objeto de configuração no seguinte arquivo de configuração `.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
```
You may notice that there are many items in here that you didn't pass arguments for. Those values are the default config items, some of which can only be edited easily in the source or via a config file, usually because it didn't seem worth it to add an argument for them.
## Isso é uma merda, vocês têm planos para melhorar?
Não, não é uma merda, você que é.
Além disso, sim, temos.
Também vamos:
- Adicionar análise de arquivos de arquivo, idealmente tratando-os como apenas mais um diretório para percorrer em busca de boas coisas.
- Continuar refinando as regras e os regex. **Mais palavras para as listas de palavras! `string[]`s para o trono `string`!**
## De quem você roubou código?
As partes de enumeração de compartilhamentos foram 'snaffled' (entendeu o que eu fiz ali?) do SharpShares, que foi escrito pelo extremamente útil Dwight Hohnstein. (https://github.com/djhohnstein/SharpShares/)
O perfil do Dwight no GitHub é como aquele corredor incrível no fundo de uma loja de ferramentas, cheio de ferramentas que fazem você pensar "oh cara, mal posso esperar para ter uma desculpa para testar este aqui de verdade..." e você definitivamente deveria dar uma olhada.
Embora nenhum código tenha sido copiado (principalmente porque é Ruby lol), nós roubamos um monte de ideias legais do `plunder2` (http://joshstone.us/plunder2/)
As listas de palavras também foram curadas a partir daquelas encontradas em algumas outras ferramentas similares, como trufflehog, shhgit, gitrobber e graudit.
## É seguro em termos de OPSEC? (O que diabos isso significa)
Pffft, não. É barulhento pra caralho.
Olha, vamos colocar assim... Se é o tipo de ambiente onde você se sentiria confiante em executar o BloodHound no modo padrão, então uhhh, sim cara... É realmente furtivo.
## Pensei que você usava essa coisa em trabalhos de red team?
*suspiro*
OK, vou te dar a resposta verdadeira.
No modo padrão, o Snaffler se parece muito com o SharpHound, de várias maneiras. Ele faz várias consultas LDAP ao AD, depois sai e tenta falar SMB com todas as máquinas Windows do domínio. Esse tipo de comportamento é praticamente garantido de te pegar em uma organização que tem seus bagulhos minimamente organizados.
NO ENTANTO...
As opções mais direcionadas do Snaffler (especialmente `-i`) são *muito* menos propensas a acionar detecções.
Sou particularmente afeiçoado a executar `Snaffler.exe -s -i C:\` em um servidor ou estação de trabalho recém-comprometido, e ainda não vi esse comportamento ser detectado.
Ainda.
## Como posso ajudar ou obter ajuda?
Se você quiser discutir pelo Slack, pode nos chamar (@l0ss ou @Sh3r4) no Slack do BloodHound, acessível em https://bloodhoundgang.herokuapp.com/, ou conversar com um grupo de contribuidores no canal #snaffler.
Você também pode nos chamar no Twitter - @mikeloss e @sh3r4_hax
Caso contrário, abra uma issue; tentaremos.