fuzzable
v2.0.7
Framework para automatizar descoberta de alvo confiável com análise estática
Os pesquisadores de vulnerabilidade que conduzem avaliações de segurança sobre o software geralmente aproveitam os recursos da difusão guiada por cobertura por meio de ferramentas poderosas como AFL ++ e Libfuzzer. Isso é importante, pois automatiza o processo de puthunting e revela condições exploráveis nas metas rapidamente. No entanto, ao encontrar bases de código grandes e complexas ou binários de código fechado, os pesquisadores precisam dedicar um tempo minuciosamente para auditar e reverter manualmente as projetá-las para identificar funções em que a exploração baseada em fuzzing pode ser útil.
Fuzzable é uma estrutura que integra tanto com o código -fonte C/C ++ e os binários para ajudar os pesquisadores de vulnerabilidade na identificação de metas de função viáveis para a difamação. Isso é feito aplicando várias heurísticas baseadas em análise estática para identificar comportamentos de risco no software e nas funções que as executa. Os pesquisadores podem então utilizar a estrutura para gerar modelos básicos de arnês, que podem ser usados para procurar vulnerabilidades ou para serem integrados como parte de um pipeline contínuo, como o projeto OSS-Fuzz do Google.
Além de executar como uma ferramenta independente, o Fuzzable também é integrado como um plug -in para o Ninja desmontador binário, com o suporte para outros back -ends de desmontagem sendo desenvolvidos.
Confira a postagem original do blog detalhando a ferramenta aqui, que destaca as especificações técnicas das heurísticas de análise estática e como essa ferramenta surgiu. Esta ferramenta também é apresentada no Black Hat Arsenal USA 2022.
Alguns alvos binários podem exigir alguma higienização (por exemplo, correspondência de assinatura ou identificação de funções a partir de inline) e, portanto, o confuso usa principalmente o ninja binário como um back -end de desmontagem devido à sua capacidade de resolver efetivamente esses problemas. Portanto, pode ser utilizado como uma ferramenta e plug -in independentes.
Como o Ninja binário não é acessível a todos e pode haver uma demanda a ser utilizada para avaliações de segurança e potencialmente escalar na nuvem, também é suportado um back -end de Fallback Angr. Eu previsto que também incorpore outros desmontadores no caminho (prioridade: ghidra).
Se você possui um comercial ninja binário, não deixe de instalar a API para uso independente da cabeça:
$ python3 /Applications/Binary Ninja.app/Contents/Resources/scripts/install_api.py
Instale com pip :
$ pip install fuzzable
Usamos poesia para gerenciamento e construção de dependência. Para fazer uma construção manual, clone o repositório com os módulos de terceiros:
$ git clone --recursive https://github.com/ex0dus-0x/fuzzable
Para instalar manualmente:
$ cd fuzzable/
# without poetry
$ pip install .
# with poetry
$ poetry install
# with poetry for a development virtualenv
$ poetry shell
Agora você pode analisar binários e/ou código -fonte com a ferramenta!
# analyzing a single shared object library binary
$ fuzzable analyze examples/binaries/libbasic.so
# analyzing a single C source file
$ fuzzable analyze examples/source/libbasic.c
# analyzing a workspace with multiple C/C++ files and headers
$ fuzzable analyze examples/source/source_bundle/
O Fuzzable pode ser facilmente instalado no mercado binário de plug -in ninja, acessando Binary Ninja > Manage Plugins e pesquisá -lo. Aqui está um exemplo do plug -in difusável em execução, precisão de identificação de metas para fuzz e avaliação de vulnerabilidade:
O Fuzzable vem com várias opções para ajudar a ajustar melhor sua análise. Mais será suportado em planos futuros e quaisquer solicitações de recurso feitas.
Para determinar a difamação, o Fuzzable utiliza várias heurísticas para determinar quais metas são as mais viáveis para segmentar para análise dinâmica. Essas heurísticas são todas ponderadas de maneira diferente usando a biblioteca de critérios do Scikit, que utiliza análise de decisão com vários critérios para determinar os melhores candidatos. Essas métricas e existem pesos podem ser vistos aqui:
| Heurística | Descrição | Peso |
|---|---|---|
| Nome amigável de fuzz | O nome do símbolo implica comportamento que ingere a entrada de arquivo/buffer | 0,3 |
| Pia arriscada | Argumentos que fluem para chamadas de risco (ou seja, memcpy) | 0,3 |
| Loops naturais | Número de loops detectados com a fronteira de domínio | 0,05 |
| Complexidade ciclomática | Complexidade do alvo da função com base nas arestas + nós | 0,05 |
| Profundidade de cobertura | Número de Callees, o alvo atravessa | 0,3 |
Como mencionado, confira a postagem técnica do blog para obter uma análise mais aprofundada do porquê e como essas métricas são utilizadas.
Muitas métricas foram amplamente inspiradas pelo trabalho original de Vincenzo Iozzo em 0 conhecimento.
Todas as metas que você deseja analisar são diversas e confusáveis não poderão explicar cada comportamento de casos da borda na meta do programa. Assim, pode ser importante durante a análise ajustar esses pesos adequadamente para ver se diferentes resultados fazem mais sentido para o seu caso de uso. Para ajustar esses pesos na CLI, basta especificar o argumento --score-weights :
$ fuzzable analyze <TARGET> --score-weights=0.2,0.2,0.2,0.2,0.2
Por padrão, Fuzzable filtrará os alvos de função com base nos seguintes critérios:
static e não expostas através de cabeçalhos. Para ver as chamadas que foram filtradas por Fuzzable , defina o sinalizador --list_ignored :
$ fuzzable analyze --list-ignored <TARGET>
No ninja binário, você pode girar essa configuração em Settings > Fuzzable > List Ignored Calls .
No caso de que a Fuzzable file falsamente chamadas importantes que devem ser analisadas, é recomendável usar --include-* argumentos para incluí-los durante a execução:
# include ALL non top-level calls that were filtered out
$ fuzzable analyze --include-nontop <TARGET>
# include specific symbols that were filtered out
$ fuzzable analyze --include-sym <SYM> <TARGET>
No ninja binário, isso é suportado por meio de Settings > Fuzzable > Include non-top level calls Symbols to Exclude .
Agora que você descobriu que seus candidatos ideais a confusos, confundíveis, também ajudarão você a gerar chicotes de preços que estão (quase) prontos para instrumentar e compilar para uso com um detectador baseado em arquivo (ou seja, afl ++, honggfuzz) ou nebroster na memória (libfuzer). Fazer isso na CLI:
# generate harness from a candidate
$ fuzzable create-harness target --symbol-name=some_unsafe_call
# make minimal and necessary modifications to the harness
$ vim target_some_unsafe_call_harness.cpp
# example compilation for AFL-QEMU, which is specified in the comments of the generated harness
$ clang target_some_unsafe_call_harness.cpp -no-pie -o target_some_unsafe_call_harness -ldl
# create your base seeds, ideally should be more well-formed for input
$ mkdir in/
$ echo "seed" >> in/seed
# start black box fuzzing
$ afl-fuzz -Q -m none -i in/ -o out/ -- ./target_some_unsafe_call_harness
Se esse destino for uma base de código fonte, o modelo de origem genérico será usado.
Se o alvo for um binário, o modelo genérico de caixa preta será usada, que idealmente pode ser usada com um modo de emulação de difamação como AFL-Qemu. Uma cópia do binário também será criada como um objeto compartilhado se o símbolo não for exportado diretamente para ser dlopen ed usando o LIEF.
No momento, esse recurso é bastante rudimentar, pois simplesmente criará um chicote de C ++ independente preenchido com os parâmetros apropriados e não será necessário o código de geração automática necessária para quaisquer comportamentos de tempo de execução (por exemplo. No entanto, os modelos criados para Fuzzable ainda devem fazer você funcionar rapidamente. Aqui estão alguns recursos ambiciosos que eu gostaria de implementar no caminho:
Fuzzable suporta gerar relatórios em vários formatos. Os atuais suportados são JSON, CSV e Markdown. Isso pode ser útil se você estiver utilizando isso como parte da automação, onde deseja ingerir a saída em um formato serializável.
Na CLI, basta passar no argumento --export com um nome de arquivo com a extensão apropriada:
$ fuzzable analyze --export=report.json <TARGET>
No ninja binário, vá para Plugins > Fuzzable > Export Fuzzability Report > ... e selecione o formato para o qual deseja exportar e o caminho para o qual deseja escrever.
Esta ferramenta será desenvolvida continuamente e qualquer ajuda de mantainers externos é apreciada!
Fuzzable é licenciado sob a licença do MIT.
