Bom dia Dano! Hoje convido você a mergulhar no tema geração de exploits. A geração de façanhas voltou nos anos barbudos. Em algum momento, as pessoas começaram a pensar em criar explorações automaticamente, em vez de fazê-las manualmente. Foi assim que surgiu uma categoria destinada a desenvolver ferramentas que possam detectar automaticamente vulnerabilidades em software e, em seguida, criar explorações para essas vulnerabilidades.

Esses instrumentos são chamados de AEG.
AEG (Automatic Exploit Generation) significa geração automática de exploits. As ferramentas AEG podem analisar programas, identificar vulnerabilidades e, em seguida, criar instruções específicas (exploits), permitindo que esses exploits sejam usados ??manualmente ou aplicados automaticamente.

A pesquisa para o desenvolvimento de ferramentas AEG é considerada pesquisa de ponta na área de segurança ofensiva.

Abaixo adicionei uma seleção de materiais sobre o tema AEG. Estou compartilhando uma seleção de pesquisas.
Seleção de materiais. Geração automática de exploits (AEG)?

2005
Automatizando ataques de mimetismo usando análise binária estática
Os sistemas de detecção de intrusões que monitoram sequências de chamadas de sistema tornaram-se recentemente mais sofisticados na definição do comportamento legítimo de aplicativos. Em particular, informações adicionais, como o valor do contador do programa e a configuração da pilha de chamadas do programa em cada chamada do sistema, têm sido utilizadas para obter uma melhor caracterização do comportamento do programa. Embora haja consenso de que esta informação adicional complica a tarefa do invasor, é menos claro até que ponto um intruso é restringido. Neste artigo, apresentamos uma nova técnica para escapar dos recursos de detecção estendidos dos sistemas de detecção de intrusão de última geração e reduzir a tarefa do intruso a um ataque de mimetismo tradicional. Dada uma sequência legítima de chamadas de sistema, nossa técnica permite que o invasor execute cada chamada de sistema no contexto de execução correto, obtendo e abrindo mão do controle do fluxo de execução da aplicação através da manipulação de ponteiros de código. Desenvolvemos uma ferramenta de análise estática para binários Intel x86 que utiliza execução simbólica para identificar automaticamente instruções que podem ser utilizadas para redirecionar o fluxo de controle e calcular as modificações necessárias no ambiente do processo. Usamos nossa ferramenta para explorar com sucesso três programas vulneráveis ??e evitar a detecção por monitores de chamadas de sistema de última geração existentes. Além disso, analisamos três aplicações do mundo real para verificar a aplicabilidade geral de nossas técnicas.

2008?
A geração automática de exploits baseada em patches é possível: técnicas e implicações
O problema de geração automática de exploits baseados em patches é: dado um programa P e uma versão corrigida do programa P', gerar automaticamente um exploit para a vulnerabilidade potencialmente desconhecida presente em P, mas corrigida em P'. Neste artigo, propomos técnicas para geração automática de exploits com base em patches e mostramos que nossas técnicas podem gerar automaticamente exploits para cinco programas da Microsoft com base em patches fornecidos pelo Windows Update. Embora nossas técnicas possam não funcionar em todos os casos, um princípio fundamental de segurança é estimar de forma conservadora as capacidades dos invasores. Assim, nossos resultados indicam que a geração automática de exploits baseada em patches deve ser considerada prática. Uma importante implicação de segurança dos nossos resultados é que os atuais esquemas de distribuição de patches que escalonam a distribuição de patches por longos períodos de tempo, como o Windows Update, podem permitir que os invasores que recebem o patch primeiro comprometam a fração significativa de hosts vulneráveis ??que ainda não receberam o patch. .

2009?
Geração automática de explorações de sequestro de fluxo de controle para vulnerabilidades de software
Bugs de software que resultam em corrupção de memória são um recurso comum e perigoso de sistemas desenvolvidos em determinadas linguagens de programação. Esses bugs são vulnerabilidades de segurança se puderem ser aproveitados por um invasor para desencadear a execução de código malicioso. Determinar se tal possibilidade existe é um processo demorado e requer conhecimentos técnicos em diversas áreas. Freqüentemente, a única maneira de ter certeza de que um bug pode de fato ser explorado por um invasor é criar um exploit completo. É esse processo que procuramos automatizar. Apresentamos um novo algoritmo que integra análise de fluxo de dados e um procedimento de decisão com o objetivo de construir explorações automaticamente. As explorações que geramos são construídas para sequestrar o fluxo de controle de um aplicativo e redirecioná-lo para código malicioso. Nosso algoritmo foi projetado para criar explorações para três classes comuns de vulnerabilidade de segurança; estouros de buffer baseados em pilha que corrompem um ponteiro de instrução armazenado, estouros de buffer que corrompem um ponteiro de função e estouros de buffer que corrompem o endereço de destino usado pelas instruções que gravam na memória. Para estas classes de vulnerabilidade apresentamos um sistema capaz de gerar explorações funcionais na presença de modificações aritméticas complexas de entradas e restrições arbitrárias. As explorações são geradas usando análise dinâmica de fluxo de dados em combinação com um procedimento de decisão. Até onde sabemos, a implementação resultante é a primeira a demonstrar a geração de exploits usando tais técnicas. Ilustramos sua eficácia em vários benchmarks, incluindo uma vulnerabilidade em um grande aplicativo de servidor do mundo real.

2011?
AEG: Geração automática de exploits
O desafio de geração automática de exploits é dado a um programa, que encontra vulnerabilidades automaticamente e gera exploits para elas. Neste artigo apresentamos o AEG, o primeiro sistema ponta a ponta para geração de exploits totalmente automática. Usamos a AEG para analisar 14 projetos de código aberto e geramos com sucesso 16 explorações de sequestro de fluxo de controle. Duas das explorações geradas (expect-5.4JUdGzvrMFDWrUUwY3toJATSeNwjn54LkCnKBPRzDuhzi5vSepHfUckJNxRL2gjkNrSqtCoRUrEDAgRwsQvVCjZbRyFTLRNyDmT1a1boZVmostramos como a geração de exploits para ataques de sequestro de fluxo de controle pode ser modelada como um problema de verificação formal, 2) propomos a execução simbólica pré-condicionada, uma nova técnica para direcionar a execução simbólica, 3) apresentamos uma abordagem geral para gerar trabalhando explorações assim que um bug é encontrado e 4) construímos o primeiro sistema ponta a ponta que encontra vulnerabilidades automaticamente e gera explorações que produzem um shell.

2012
Liberando MAYHEM no código binário
Neste artigo apresentamos o MA YHEM, um novo sistema para encontrar automaticamente bugs exploráveis ??em programas binários (isto é, executáveis). Cada bug relatado por MA YHEM é acompanhado por uma exploração funcional de geração de shell. As explorações funcionais garantem a solidez e que cada relatório de bug seja crítico para a segurança e acionável. MA YHEM funciona em código binário bruto sem informações de depuração. Para tornar possível a geração de exploits em nível binário, MA YHEM aborda dois grandes desafios técnicos: gerenciar ativamente caminhos de execução sem esgotar a memória e raciocinar sobre índices de memória simbólica, onde uma carga ou um endereço de armazenamento depende da entrada do usuário. Para tanto, propomos duas novas técnicas: 1) execução simbólica híbrida para combinar execução online e offline (concólica) para maximizar os benefícios de ambas as técnicas, e 2) modelagem de memória baseada em índice, uma técnica que permite MA YHEM raciocinar de forma eficiente. sobre memória simbólica no nível binário. Usamos o MA YHEM para encontrar e demonstrar 29 vulnerabilidades exploráveis ??em programas Linux e Windows, 2 das quais não estavam documentadas anteriormente.

2012
CRAX: Análise de falhas de software para geração automática de exploits modelando ataques como continuações simbólicas
Apresentamos um framework simples capaz de gerar automaticamente ataques que exploram vulnerabilidades de sequestro de fluxo de controle. Analisamos determinadas falhas de software e realizamos execução simbólica em modo concólico, usando um modelo de ambiente de sistema completo. A estrutura usa uma abordagem ponta a ponta para gerar explorações para vários aplicativos, incluindo 16 programas de benchmark de média escala e vários aplicativos de grande escala, como Mplayer (um reprodutor de mídia), Unrar (um arquivador) e Foxit (um leitor de PDF ), com estouro de pilha/heap, estouro off-by-one, uso de variável não inicializada, vulnerabilidades de string de formato. Notavelmente, esses aplicativos têm sido normalmente considerados presas difusas, mas ainda exigem um processo manual com conhecimento de segurança para produzir explorações reforçadas pela mitigação. Usar nosso sistema para produzir explorações é um processo totalmente automatizado e direto para software travado sem fonte. Produzimos as explorações em seis minutos para programas de média escala e em até 80 minutos para mplayer (cerca de 500.000 LOC), após reduções de restrições. Nossos resultados demonstram que a ligação entre bugs de software e vulnerabilidades de segurança pode ser automaticamente superada.

2013?
Geração de exploração com reconhecimento de transformação usando um HI-CFG?
Uma tarefa comum para analistas de segurança é determinar se construções de código potencialmente inseguras (conforme encontradas por análise estática ou revisão de código) podem ser acionadas por uma entrada controlada pelo invasor no programa em análise. Chamamos esse problema de geração de exploração de prova de conceito (POC). A geração de exploits é um desafio para automatizar porque requer raciocínio preciso em uma grande base de código; na prática, geralmente é uma tarefa manual. Uma abordagem intuitiva para a geração de exploits é dividir a computação relevante de um programa em uma sequência de transformações que mapeiam um valor de entrada no valor que pode desencadear um exploit. Automatizamos essa intuição descrevendo uma abordagem para descobrir a estrutura de buffer (a cadeia de buffers usada entre as transformações) de um programa e usamos essa estrutura para construir uma entrada de exploração, invertendo uma transformação por vez. Propomos uma nova representação de programa, um gráfico híbrido de fluxo de informação e controle (HI-CFG), e fornecemos algoritmos para construir um HI-CFG a partir de traços de instruções. Em seguida, descrevemos como orientar a exploração do programa usando execução simbólica para pesquisar com eficiência pré-imagens de transformação. Implementamos nossas técnicas em uma ferramenta que opera em aplicações em formato binário x86. Em dois estudos de caso, discutimos como nossa ferramenta cria explorações POC para (i) uma vulnerabilidade em uma biblioteca de renderização de PDF que pode ser acessada por meio de vários estágios de transformação diferentes e (ii) uma vulnerabilidade no estágio de processamento de um formato de documento específico no AbiWord.

2013?
Geração automática de exploração polimórfica para vulnerabilidades de software
A geração de explorações a partir da perspectiva dos invasores é uma abordagem eficaz para a análise da gravidade de vulnerabilidades conhecidas. No entanto, continua sendo um problema em aberto gerar pelo menos um exploit usando um binário de programa e uma entrada anormal conhecida que trava o programa, sem mencionar vários exploits. Para resolver esse problema, neste artigo propomos o PolyAEG, um sistema que gera automaticamente múltiplas explorações para um programa vulnerável usando uma entrada anormal correspondente. Para gerar explorações polimórficas, aproveitamos totalmente diferentes instruções de trampolim para sequestrar o fluxo de controle e redirecioná-lo para código malicioso no contexto de execução. Demonstramos que, dado um programa vulnerável e uma de suas entradas anormais, nosso sistema pode gerar exploits polimórficos para o programa. Geramos com sucesso exploits de sequestro de fluxo de controle para 8 programas em nosso experimento. Especificamente, geramos 4.724 explorações usando apenas uma entrada anormal para o IrfanView, um visualizador de imagens amplamente utilizado.

2014
Análise de falhas de software para geração automática de exploits em programas binários
Este artigo apresenta um novo método, capaz de gerar automaticamente ataques a programas binários a partir de falhas de software. Analisamos falhas de software com um modelo de falha simbólica realizando execuções concólicas seguindo os caminhos direcionados à falha, usando um modelo de ambiente de sistema completo e endereço concreto mapeado na memória simbólica em . Propomos um novo método seletivo de entrada simbólica e avaliação preguiçosa em variáveis ??pseudo simbólicas para lidar com ponteiros simbólicos e acelerar o processo. Esta é uma abordagem ponta a ponta capaz de criar explorações a partir de entradas de falha ou explorações existentes para vários aplicativos, incluindo a maioria dos programas de benchmark existentes e vários aplicativos de grande escala, como um processador de texto (Microsoft office word), um media player (mpalyer), um arquivador (unrar) ou um leitor de PDF (foxit). Podemos lidar com tipos de vulnerabilidade, incluindo estouros de pilha e heap, string de formato e o uso de variáveis ??não inicializadas. Notavelmente, esses aplicativos se tornaram alvos de testes de fuzz de software, mas ainda exigem um processo manual com conhecimento de segurança para produzir explorações reforçadas por mitigação. Usar esse método para gerar explorações é um processo automatizado para falhas de software sem código-fonte. O método proposto é mais simples, mais geral, mais rápido e pode ser escalado para programas maiores que os sistemas existentes. Produzimos explorações em um minuto para a maioria dos programas de benchmark, incluindo o mplayer. Também transformamos explorações existentes do Microsoft Office Word em novas explorações em quatro minutos. A melhor aceleração é 7.211 vezes mais rápida que a tentativa inicial. Para vulnerabilidade de heap overflow, podemos explorar automaticamente a macro unlink() da glibc, que anteriormente exigia esforços sofisticados de hacking.

2014
Análise de falhas do programa com base na análise Taint
A análise de exceções de software pode não apenas melhorar a estabilidade do software antes de colocá-lo no mercado, mas também otimizar a prioridade das atualizações de patch posteriormente. Propomos uma abordagem mais prática de análise de exceções de software baseada na análise de contaminação, a partir do ponto de vista de que uma exceção do software pode ser explorada por um invasor. Ele primeiro identifica o tipo de exceções e, em seguida, faz a análise de contaminação no rastreamento entre o ponto de entrada do programa até o ponto de exceção e registra as informações de contaminação do conjunto de memória e dos registros. Finalmente, dá o resultado integrando a gravação acima e a subsequente análise das instruções. Implementamos esta abordagem em nossa estrutura de análise de exceções ExpTracer e fazemos a avaliação com algumas exceções exploráveis/não exploráveis, o que mostra que nossa abordagem é mais precisa na identificação de exceções em comparação com as ferramentas atuais.

2014
Explorar a geração de falhas de software
Normalmente monitoramos e observamos falhas para medir a confiabilidade e a qualidade de um sistema. Pelo contrário, as falhas são manipuladas no processo de depuração para correção das falhas ou por invasores para acesso não autorizado ao sistema. Revisamos vários problemas para determinar se as falhas (especialmente a falha do software) podem ser alcançadas e controladas por um invasor. Este tipo de esforços é chamado de exploração e pode ser uma medida da confiabilidade de um sistema falido.

2015?
Explorar a geração de vazamentos de fluxo de informações em programas orientados a objetos
Apresentamos um método para gerar explorações automáticas para vazamentos de fluxo de informações em programas orientados a objetos. Nossa abordagem combina autocomposição e execução simbólica para compor uma fórmula de insegurança para uma determinada política de fluxo de informações e uma especificação do nível de segurança dos locais do programa. A fórmula da insegurança dá então origem a um modelo que é usado para gerar dados de entrada para a exploração. Foi desenvolvida uma ferramenta protótipo chamada KEG que implementa a abordagem descrita para programas Java, que gera exploits como testes JUnit executáveis.

2015?
Geração automática de explorações orientadas a dados
À medida que as soluções de defesa contra ataques de sequestro de fluxo de controle ganham ampla implantação, as explorações orientadas para o controle de erros de memória tornam-se difíceis. Como alternativa, os ataques direcionados a dados que não são de controle não exigem o desvio do fluxo de controle do aplicativo durante um ataque. Embora se saiba que tais ataques orientados a dados podem causar danos significativos, nenhum método sistemático para construí-los automaticamente a partir de erros de memória foi desenvolvido. Neste trabalho, desenvolvemos uma nova técnica chamada costura de fluxo de dados, que sistematicamente encontra maneiras de unir fluxos de dados no programa para gerar explorações orientadas a dados. Construímos um protótipo incorporando nossa técnica em uma ferramenta chamada FLOWSTITCH que funciona diretamente em binários Windows e Linux. Em nossos experimentos, descobrimos que o FLOWSTITCH constrói automaticamente 16 ataques previamente desconhecidos e três ataques conhecidos orientados a dados a partir de oito programas vulneráveis ??do mundo real. Todas as explorações criadas automaticamente respeitam restrições CFI e DEP refinadas, e 10 das 19 explorações funcionam com defesas ASLR padrão habilitadas. As explorações construídas podem causar danos significativos, como divulgação de informações confidenciais (por exemplo, senhas e chaves de criptografia) e aumento de privilégios.

2015?
Geração automatizada de exploits para vulnerabilidades de estouro de buffer de pilha
Um método automatizado para geração de exploração é apresentado. Este método permite construir explorações para vulnerabilidades de estouro de buffer de pilha e priorizar bugs de software. O método baseia-se na análise dinâmica e na execução simbólica de programas. Pode ser aplicado a binários de programas e não requer informações de depuração. O método proposto foi utilizado para desenvolver uma ferramenta para geração de exploits. Essa ferramenta foi usada para gerar explorações para oito vulnerabilidades em programas Linux e Windows, das quais três não foram corrigidas no momento da redação deste artigo.

2016
Rumo à geração automatizada de exploits para sistemas embarcados
A descoberta manual de vulnerabilidades e o desenvolvimento de explorações em um executável são tarefas muito desafiadoras para os desenvolvedores. Portanto, a automação dessas tarefas está se tornando interessante na área de segurança de software. Neste artigo, implementamos uma abordagem de geração automatizada de exploits para firmware de sistemas embarcados, estendendo uma estrutura de análise dinâmica existente chamada Avatar. Os sistemas embarcados ocupam uma parcela significativa do mercado, mas carecem dos recursos de segurança típicos encontrados em computadores de uso geral, tornando-os propensos a vulnerabilidades críticas. Discutimos diversas técnicas para descobrir vulnerabilidades automaticamente e gerar explorações para sistemas embarcados e avaliamos nossa abordagem proposta gerando explorações para dois firmware vulneráveis ??escritos para um popular microcontrolador ARM Cortex-M3.

2016
Sok: estado da arte da guerra Técnicas ofensivas em análise binária?
Encontrar e explorar vulnerabilidades em código binário é uma tarefa desafiadora. A falta de informações semanticamente ricas e de alto nível sobre estruturas de dados e construções de controle torna a análise das propriedades do programa mais difícil de escalar. No entanto, a importância da análise binária está aumentando. Em muitas situações, a análise binária é a única maneira possível de provar (ou refutar) propriedades sobre o código que é realmente executado. Neste artigo, apresentamos uma estrutura de análise binária que implementa uma série de técnicas de análise que foram propostas no passado. Apresentamos uma implementação sistematizada dessas técnicas, que permite que outros pesquisadores as componham e desenvolvam novas abordagens. Além disso, a implementação destas técnicas num quadro unificador permite a comparação direta destas abordagens e a identificação das suas vantagens e desvantagens. A avaliação incluída neste artigo é realizada usando um conjunto de dados recente criado pela DARPA para avaliar a eficácia das técnicas de análise de vulnerabilidade binária. Nossa estrutura é de código aberto e está disponível para a comunidade de segurança.

2017?
Execução Simbólica Orientada a Chamadas de Serviço do Sistema do Framework Android com Aplicações para Descoberta de Vulnerabilidades e Geração de Exploit
Android Application Framework é parte integrante e fundamental do sistema Android. Cada um dos 1,4 bilhão de dispositivos Android depende dos serviços de sistema do Android Framework para gerenciar aplicativos e recursos do sistema. Dado o seu papel crítico, uma vulnerabilidade na estrutura pode ser explorada para lançar ataques cibernéticos em grande escala e causar danos graves à segurança e privacidade dos utilizadores. Recentemente, muitas vulnerabilidades no Android Framework foram expostas, mostrando que ele é vulnerável e explorável. No entanto, a maior parte da investigação existente tem-se limitado à análise de aplicações Android, embora existam muito poucas técnicas e ferramentas desenvolvidas para analisar o Android Framework. Em particular, até onde sabemos, não há nenhum trabalho anterior que analise a estrutura por meio de execução simbólica, uma abordagem que provou ser muito poderosa para descoberta de vulnerabilidades e geração de exploits. Projetamos e construímos o primeiro sistema, Centaur, que permite a execução simbólica do Android Framework. Devido a algumas características únicas da estrutura, como a natureza do middleware e a extraordinária complexidade, muitos novos desafios surgem e são enfrentados no Centaur. Além disso, demonstramos como o sistema pode ser aplicado para descobrir novas instâncias de vulnerabilidade, que podem ser exploradas por vários ataques recentemente descobertos contra a estrutura, e para gerar explorações de PoC.

2017?
Síntese modular de explorações de heap
Os erros de memória continuam a comprometer a segurança dos sistemas atuais. Esforços recentes para sintetizar automaticamente explorações para buffer overflows baseados em pilha prometem ajudar a avaliar a gravidade de uma vulnerabilidade mais rapidamente e aliviar a carga do raciocínio manual. No entanto, a geração de explorações de heap tem estado fora do escopo de tais métodos até agora. Neste artigo, investigamos o problema de geração automática de explorações de heap, que, além de encontrar a vulnerabilidade, requer uma interação complexa com o gerenciador de heap. Identificamos os desafios envolvidos na localização automática dos parâmetros e sequências de interação corretos para tais ataques, que tradicionalmente exigem análise manual. Para enfrentar esses desafios, apresentamos uma abordagem modular projetada para minimizar as suposições feitas sobre o gerenciador de heap usado pela aplicação alvo. Nosso sistema protótipo é capaz de encontrar explorações primitivas em seis implementações binárias de gerenciadores de heap baseados em Windows e UNIX e aplicá-las para explorar com sucesso duas aplicações do mundo real.

2017?
Construir restrição de exploração na análise de falhas ignorando Canary
A execução simbólica seletiva é uma tecnologia comum de teste de programas. Desenvolvidos com base nele, alguns sistemas de análise de falhas são frequentemente usados ??para testar a fragilidade do programa através da construção de restrições de exploração, como o CRAX. A partir do estudo da análise de falhas baseada na execução simbólica, este artigo conclui que esta tecnologia não pode contornar os mecanismos de proteção da pilha canário. Este artigo faz com que a melhoria use o gancho da API no Linux. Os resultados experimentais mostram que o uso do gancho da API pode resolver efetivamente o problema de que a análise de falhas não consegue contornar a proteção canário.

2017?
Avaliando automaticamente falhas causadas por heap overflows
O heap overflow é uma das vulnerabilidades mais amplamente exploradas, com um grande número de instâncias de heap overflow relatadas todos os anos. É importante decidir se uma falha causada por heap overflow pode ser transformada em uma exploração. A avaliação eficiente e eficaz da exploração de falhas facilita a identificação de vulnerabilidades graves e, assim, a priorização de recursos. Neste artigo, propomos as primeiras métricas para avaliar falhas de heap overflow com base tanto no aspecto do ataque quanto no aspecto da viabilidade. Apresentamos ainda o HCSIFTER, uma nova solução para avaliar automaticamente a explorabilidade de instâncias de heap overflow sob nossas métricas. Dada uma falha baseada em heap, o HCSIFTER detecta com precisão estouros de heap por meio de execução dinâmica, sem qualquer código-fonte ou informações de depuração. Em seguida, ele usa vários métodos novos para extrair informações de execução do programa necessárias para quantificar a gravidade do heap overflow usando nossas métricas. Implementamos um protótipo HCSIFTER e o aplicamos para avaliar nove programas com vulnerabilidades de heap overflow. O HCSIFTER relata com sucesso que cinco vulnerabilidades de heap overflow são altamente exploráveis ??e duas vulnerabilidades de overflow são improváveis ??de serem exploradas. Também forneceu avaliações quantitativas para outros dois programas. Em média, leva apenas cerca de dois minutos para avaliar uma falha de heap overflow. O resultado da avaliação demonstra a eficácia e a eficiência do HCSIFTER.

2017?
Geração automática de explorações de comunicação entre componentes para aplicativos Android
Embora uma grande variedade de abordagens identifiquem vulnerabilidades em aplicativos Android, nenhuma tenta determinar a capacidade de exploração dessas vulnerabilidades. A explorabilidade pode ajudar a reduzir falsos positivos da análise de vulnerabilidade e pode ajudar os engenheiros na triagem de bugs. Especificamente, um dos principais vetores de ataque dos aplicativos Android é sua interface de comunicação entre componentes, onde os aplicativos podem receber mensagens chamadas Intents. Neste artigo, fornecemos a primeira abordagem para gerar explorações automaticamente para aplicativos Android, chamada LetterBomb, contando com uma análise estática baseada em execução simbólica sensível ao caminho combinada e o uso de instrumentação de software e oráculos de teste. Executamos o LetterBomb em 10.000 aplicativos Android do Google Play, onde identificamos 181 explorações de 835 aplicativos vulneráveis. Comparado a uma abordagem de detecção de última geração para três vulnerabilidades baseadas em ICC, o LetterBomb obtém de 33% a 60% mais vulnerabilidades a uma velocidade de 6,66 a 7 vezes mais rápida.

2018?
Rumo à geração automatizada de primitivos de exploração para navegadores da Web
A crescente dependência de software e a crescente complexidade de tais sistemas criam e alimentam a superfície de ataque para vulnerabilidades exploráveis. Os pesquisadores de segurança se esforçam muito para desenvolver explorações e analisar explorações existentes com o objetivo de permanecer à frente do que há de mais moderno em ataques e defesas. A necessidade de sistemas automatizados que operem em escala, velocidade e eficiência é, portanto, inegável. Dada a sua complexidade e grande base de usuários, os navegadores da Web representam um alvo atraente. Devido a várias estratégias de mitigação, a exploração de uma vulnerabilidade do navegador tornou-se uma tarefa demorada e de várias etapas: criar uma exploração funcional, mesmo a partir de uma entrada com falha, é uma tarefa que consome muitos recursos e pode levar uma quantidade substancial de tempo para ser concluída. Em muitos casos, a entrada que desencadeia uma vulnerabilidade segue um caminho de falha, mas não entra num estado explorável. Neste artigo, apresentamos novos métodos para melhorar significativamente e automatizar parcialmente o processo de desenvolvimento de explorações de navegador. Nossa abordagem é baseada na observação de que um analista normalmente executa certas etapas manuais de análise que podem ser automatizadas. Isso serve ao propósito de propagar os dados controlados e induzidos por bugs para um local específico do programa para realizar uma ação desejada. Essas ações incluem conseguir escrever o que-onde ou controlar as primitivas do ponteiro de instrução. Eles são úteis para estender o controle sobre o programa alvo e são necessários para a execução bem-sucedida do código, o objetivo final do adversário. Implementamos um protótipo de nossa abordagem chamado PrimGen. Para uma determinada vulnerabilidade do navegador, ele é capaz de criar automaticamente objetos de dados que levam a execução a uma ação desejada. Mostramos em nossa avaliação que nossa abordagem é capaz de gerar oportunidades de exploração novas e até então desconhecidas para vulnerabilidades do mundo real no Mozilla Firefox, Internet Explorer e Google Chrome. Usando pequenos modelos, o PrimGen gera entradas que conduzem primitivas específicas. No total, PrimGen encontrou 4JUdGzvrMFDWrUUwY3toJATSeNwjn54LkCnKBPRzDuhzi5vSepHfUckJNxRL2gjkNrSqtCoRUrEDAgRwsQvVCjZbRyFTLRNyDmT1a1boZV.

2018?
TEETHER: Roendo Ethereum para explorar automaticamente contratos inteligentes
Criptomoedas como o Bitcoin não apenas fornecem uma moeda descentralizada, mas também uma forma programática de processar transações. Ethereum, a segunda maior criptomoeda depois do Bitcoin, é a primeira a fornecer uma linguagem Turing-completa para especificar o processamento de transações, permitindo assim os chamados contratos inteligentes. Isto proporciona um cenário oportuno para os atacantes, uma vez que as vulnerabilidades de segurança estão intimamente ligadas aos ganhos financeiros. Neste artigo, consideramos o problema da identificação automática de vulnerabilidades e geração de exploits para contratos inteligentes. Desenvolvemos uma definição genérica de contratos vulneráveis ??e a utilizamos para construir o TEETHER, uma ferramenta que permite criar um exploit para um contrato dado apenas o seu bytecode binário. Realizamos uma análise em larga escala de todos os 38.757 contratos Ethereum exclusivos, 815 dos quais nossa ferramenta encontra explorações funcionais – completamente automatizadas.

2018?
Levantamento de técnicas automatizadas de detecção de vulnerabilidades e geração de exploits em sistemas de raciocínio cibernético?
O software está em toda parte, desde sistemas de missão crítica, como centrais elétricas industriais, marca-passos e até eletrodomésticos. Esta crescente dependência da tecnologia e a crescente complexidade do software têm sérias implicações de segurança, pois significa que estamos potencialmente rodeados de software que contém vulnerabilidades exploráveis. Estes desafios tornaram a análise binária uma importante área de investigação em ciência da computação e enfatizaram a necessidade de construir sistemas de análise automatizados que possam operar em escala, velocidade e eficiência; tudo isso enquanto atua com a habilidade de um especialista humano. Embora tenham sido feitos grandes progressos nesta área de investigação, continuam a existir limitações e desafios em aberto a serem enfrentados. Reconhecendo esta necessidade, a DARPA patrocinou o Cyber ??Grand Challenge (CGC), uma competição para mostrar o estado da arte atual em sistemas que funcionam; detecção automatizada de vulnerabilidades, geração de exploits e correção de software. Este artigo é um levantamento das técnicas de detecção de vulnerabilidades e geração de exploits, tecnologias subjacentes e trabalhos relacionados de dois dos sistemas vencedores Mayhem e Mechanical Phish.

2018?
Revery: da prova de conceito ao explorável?
A geração automática de exploits é um desafio aberto. As soluções existentes geralmente exploram em profundidade os caminhos de falha, ou seja, caminhos seguidos por entradas de prova de conceito (PoC) que desencadeiam vulnerabilidades, e geram explorações quando estados exploráveis ??são encontrados ao longo dos caminhos. No entanto, os estados exploráveis ??nem sempre existem em caminhos de falha. Além disso, as soluções existentes dependem fortemente da execução simbólica e não são escaláveis ??na exploração de caminhos e na geração de explorações. Além disso, poucas soluções poderiam explorar vulnerabilidades baseadas em heap. Neste artigo, propomos uma nova solução Revery para procurar estados exploráveis ??em caminhos divergentes de caminhos com falha e gerar explorações de sequestro de fluxo de controle para vulnerabilidades baseadas em heap. Ele adota três novas técnicas: (1) um dígrafo contribuidor de layout para caracterizar o layout de memória de uma vulnerabilidade e suas instruções contribuidoras; (2) uma solução de fuzzing orientada para layout para explorar caminhos divergentes, que possuem layouts de memória semelhantes aos caminhos de falha, a fim de pesquisar estados mais exploráveis ??e gerar entradas divergentes correspondentes; (3) uma solução de costura de fluxo de controle para unir caminhos com falhas e caminhos divergentes e sintetizar entradas EXP capazes de acionar vulnerabilidades e estados exploráveis. Desenvolvemos um protótipo do Revery baseado no mecanismo de análise binária angr e o avaliamos em um conjunto de 19 programas CTF (capture the flag). Os resultados do experimento mostraram que ele poderia gerar explorações para 9 (4JUdGzvrMFDWrUUwY3toJATSeNwjn54LkCnKBPRzDuhzi5vSepHfUckJNxRL2gjkNrSqtCoRUrEDAgRwsQvVCjZbRyFTLRNyDmT1a1boZV.

2018?
Pangr: uma estrutura automática de detecção e exploração de vulnerabilidades baseada em comportamento
Hoje em dia, com o tamanho e a complexidade do software aumentando rapidamente, as vulnerabilidades estão se tornando diversificadas e difíceis de identificar. Não é prático detectar e explorar vulnerabilidades por construção manual. Portanto, um método automático eficiente de detecção e exploração de vulnerabilidades de software é uma demanda crítica. Este artigo implementa o Pangr, um sistema completo para detecção, exploração e correção automática de vulnerabilidades. Pangr constrói um modelo completo de vulnerabilidade baseado em seu comportamento de disparo para identificar vulnerabilidades e gerar esquemas de exploração ou exploração. De acordo com o tipo e característica da vulnerabilidade, o Pangr pode gerar o patch específico para o software. No experimento, testamos 20 programas vulneráveis ??em máquinas Linux de 32 bits. Pangr detectou 16 vulnerabilidades, gerou 10 exp e corrigiu 14 programas.

2018?
Heaphopper: trazendo verificação de modelo limitado para segurança de implementação de heap
Os ataques de metadados de heap tornaram-se uma das principais formas pelas quais os invasores exploram vulnerabilidades de corrupção de memória. Embora os desenvolvedores de implementação de heap tenham introduzido mitigações para prevenir e detectar corrupção, ainda é possível que os invasores contornem-nas. Em parte, isso ocorre porque essas mitigações são criadas e avaliadas sem uma base de princípios, resultando, em muitos casos, em tentativas complexas, ineficientes e ineficazes de defesas de metadados heap. Neste artigo apresentamos o HEAPHOPPER, uma abordagem automatizada, baseada em verificação de modelo e execução simbólica, para analisar a explorabilidade de implementações de heap na presença de corrupção de memória. Usando o HEAPHOPPER, fomos capazes de realizar uma análise sistemática de diferentes implementações de heap amplamente utilizadas, encontrando fraquezas surpreendentes nelas. Nossos resultados mostram, por exemplo, como um mecanismo de cache recém-introduzido no ptmalloc (a implementação do alocador de heap usada pela maioria das distribuições Linux) enfraquece significativamente sua segurança. Além disso, HEAPHOPPER nos orientou na implementação e avaliação de melhorias na segurança do ptmalloc, substituindo uma tentativa recente e ineficaz de mitigar uma forma específica de corrupção de metadados heap por uma defesa eficaz

2018?
FUZE: Para facilitar a geração de exploração para vulnerabilidades de uso após liberação do kernel
Os fornecedores de software geralmente priorizam a correção de bugs com base na facilidade de exploração. No entanto, determinar com precisão a explorabilidade normalmente leva horas enormes e requer esforços manuais significativos. Para resolver esse problema, técnicas automatizadas de geração de exploits podem ser adotadas. Na prática, no entanto, eles exibem uma capacidade insuficiente para avaliar a explorabilidade, particularmente para as vulnerabilidades Use-After-Free (UAF) do kernel. Isso se deve principalmente à complexidade da exploração do UAF, bem como à escalabilidade de um kernel do sistema operacional. Neste artigo, propomos, portanto, o FUZE, um novo framework para facilitar o processo de exploração do kernel UAF. O princípio de design por trás dessa técnica é que esperamos que a facilidade de elaboração de uma exploração possa aumentar a capacidade de um analista de segurança de avaliar a explorabilidade de uma vulnerabilidade UAF do kernel. Tecnicamente, o FUZE utiliza difusão do kernel junto com execução simbólica para identificar, analisar e avaliar as chamadas do sistema valiosas e úteis para a exploração do UAF do kernel. Além disso, ele aproveita o rastreamento dinâmico e um solucionador de restrições pronto para uso para orientar a manipulação de objetos vulneráveis. Para demonstrar a utilidade do FUZE, implementamos o FUZE em um sistema Linux de 64 bits estendendo uma estrutura de análise binária e um fuzzer de kernel. Usando 15 vulnerabilidades UAF do kernel do mundo real em sistemas Linux, demonstramos então que o FUZE poderia não apenas aumentar a capacidade de exploração do UAF do kernel, mas também diversificar as explorações funcionais. Além disso, mostramos que o FUZE poderia facilitar o desvio da mitigação de segurança, tornando a avaliação da explorabilidade menos desafiadora e mais eficiente.

2018?
Geração automatizada de exploits de ponta a ponta para validar a segurança de projetos de processadores
Este artigo apresenta Coppelia, uma ferramenta ponta a ponta que, dado um design de processador e um conjunto de invariantes críticos para a segurança, gera automaticamente programas de exploração completos e reproduzíveis para ajudar os projetistas a encontrar, contextualizar e avaliar a ameaça à segurança de vulnerabilidades de hardware. Na Coppelia, desenvolvemos um mecanismo de execução simbólica reversa orientado a hardware com um novo método de costura de ciclo e técnica de validação rápida, juntamente com diversas otimizações para geração de exploits. Em seguida, adicionamos stubs de programa para concluir a exploração. Avaliamos o Coppelia em três CPUs de arquiteturas diferentes. Coppelia é capaz de encontrar e gerar explorações para 29 das 31 vulnerabilidades conhecidas nessas CPUs, incluindo 11 vulnerabilidades que as ferramentas comerciais e acadêmicas de verificação de modelos não conseguem encontrar. Todas as explorações geradas podem ser reproduzidas com sucesso em uma placa FPGA. Além disso, Coppelia encontra 4 novas vulnerabilidades junto com explorações nessas CPUs. Também usamos o Coppelia para verificar se um patch de segurança realmente corrigiu uma vulnerabilidade e para refinar um conjunto de afirmações.

2018?
Programação Orientada a Blocos: Automatizando Ataques Somente Dados
Com a implantação generalizada do Control-Flow Integrity (CFI), os ataques de sequestro de fluxo de controle e, consequentemente, os ataques de reutilização de código, são significativamente mais difíceis. O CFI limita o fluxo de controle a locais bem conhecidos, restringindo severamente a execução arbitrária de códigos. Avaliar a superfície de ataque restante de um aplicativo sob defesas avançadas de sequestro de fluxo de controle, como CFI e shadow stacks, permanece um problema em aberto. Apresentamos o BOPC, um mecanismo para avaliar automaticamente se um invasor pode executar código arbitrário em um binário reforçado com defesas CFI/shadow stack. O BOPC calcula explorações para um programa alvo a partir de especificações de carga escritas em uma linguagem Turingcomplete de alto nível chamada SPL, que abstrai a arquitetura e os detalhes específicos do programa. As cargas SPL são compiladas em um rastreamento de programa que executa o comportamento desejado sobre o binário de destino. A entrada para o BOPC é uma carga útil do SPL, um ponto de partida (por exemplo, de uma falha do fuzzer) e uma primitiva de gravação de memória arbitrária que permite a corrupção do estado da aplicação. Para mapear cargas SPL para um rastreamento de programa, o BOPC apresenta a Programação Orientada a Blocos (BOP), uma nova técnica de reutilização de código que utiliza blocos básicos inteiros como gadgets ao longo de caminhos de execução válidos no programa, ou seja, sem violar políticas CFI ou shadow stack. Descobrimos que o problema de mapear cargas úteis para rastreamentos de programas é NP-difícil, então o BOPC primeiro reduz o espaço de busca removendo caminhos inviáveis ??e então usa heurística para guiar a busca para caminhos prováveis. BOPC codifica a carga útil do BOP como um conjunto de gravações de memória. Executamos 13 cargas SPL aplicadas a 10 aplicativos populares. O BOPC encontra com sucesso cargas úteis e rastreamentos de execução complexos - que provavelmente não teriam sido encontrados por meio de análise manual - enquanto segue o gráfico de fluxo de controle do alvo sob uma política financeira ideal em 81% dos casos.

2018?
Manipulação automática de layout de heap para exploração
A manipulação do layout de heap é essencial para explorar vulnerabilidades de corrupção de memória baseadas em heap. Neste artigo apresentamos a primeira abordagem automática para o problema, baseada em busca pseudo-aleatória em caixa preta. Nossa abordagem procura as entradas necessárias para colocar a fonte de um buffer overflow ou underflow baseado em heap próximo a objetos alocados em heap que um desenvolvedor de exploit, ou sistema de geração automática de exploit, deseja ler ou corromper. Apresentamos uma estrutura para benchmarking de algoritmos de manipulação de layout de heap e a usamos para avaliar nossa abordagem em vários alocadores do mundo real, mostrando que a pesquisa pseudo-aleatória em caixa preta pode ser altamente eficaz. Apresentamos então o SHRIKE, um novo sistema que pode realizar manipulação automática de layout de heap no interpretador PHP e pode ser usado na construção de exploits de sequestro de fluxo de controle. A partir dos testes de regressão do PHP, o SHRIKE descobre fragmentos de código PHP que interagem com o heap do interpretador de maneiras úteis, como fazer alocações e desalocações de tamanhos específicos ou alocar objetos contendo dados confidenciais, como ponteiros. SHRIKE então usa nosso algoritmo de busca para reunir esses fragmentos em programas, procurando por um que atinja o layout de heap desejado. O SHRIKE permite que um desenvolvedor de exploração se concentre nos conceitos de nível superior de uma exploração e adie a resolução das restrições de layout de heap para o SHRIKE. Demonstramos isso usando SHRIKE na construção de uma exploração de sequestro de fluxo de controle para o interpretador PHP.

2018?
Geração automática de exploits para vulnerabilidade de buffer overflow
Vulnerabilidades de buffer overflow são amplamente encontradas em software. Encontrar essas vulnerabilidades e identificar se elas podem ser exploradas é muito importante. No entanto, não é fácil encontrar todas as vulnerabilidades de buffer overflow em programas de software e é mais difícil encontrar e explorar essas vulnerabilidades em programas binários. Este artigo propõe um método e uma ferramenta correspondente que encontra automaticamente vulnerabilidades de buffer overflow em programas binários e, em seguida, gera automaticamente explorações para a vulnerabilidade. A ferramenta usa execução simbólica para pesquisar o software alvo e encontrar possíveis vulnerabilidades de buffer overflow e, em seguida, tentar contornar a proteção do sistema escolhendo diferentes métodos de exploração de acordo com os diferentes níveis de proteção. Finalmente, a exploração da vulnerabilidade do software é gerada usando o solucionador de restrições. O método e a ferramenta podem encontrar vulnerabilidades automaticamente e gerar explorações para três tipos de proteção: sem proteção do sistema, com proteção de randomização de layout de espaço de endereço e com proteção não executável de pilha.

2018?
A próxima era do AlphaHacking Uma pesquisa sobre técnicas automáticas de detecção, exploração e correção de vulnerabilidades de software
Com o sucesso do Cyber ??Grand Challenge (CGC) patrocinado pela DARPA, o tema do Sistema Autônomo de Raciocínio Cibernético (CRS) atraiu recentemente grande atenção da indústria e da academia. A utilização de um sistema automatizado para detectar, explorar e corrigir vulnerabilidades de software parece muito atraente devido à sua escalabilidade e economia em comparação com a solução baseada em especialistas humanos. Neste artigo, apresentamos um extenso levantamento de trabalhos representativos anteriores relacionados às tecnologias subjacentes de um CRS, incluindo detecção, exploração e correção de vulnerabilidades. Como um complemento importante, revisamos vários estudos pioneiros que exploram o potencial das tecnologias de aprendizado de máquina neste campo e apontamos que o desenvolvimento futuro do CRS Autônomo é inseparável do aprendizado de máquina.

2019?
KEPLER: Facilitando a avaliação primitiva de sequestro de fluxo de controle para vulnerabilidades do kernel Linux
A geração automática de exploits é um problema desafiador. Uma parte desafiadora da tarefa é conectar um estado explorável identificado (exploração primitiva) para desencadear a execução de carga útil de reutilização de código (por exemplo, ROP). Uma primitiva de sequestro de fluxo de controle é um dos recursos mais comuns para exploração. No entanto, devido aos desafios de mitigações de exploração amplamente implementadas, armadilhas ao longo de um caminho de exploração e primitivas inadequadas, é difícil até mesmo criar manualmente uma exploração com uma primitiva de sequestro de fluxo de controle para um kernel Linux moderno e pronto para uso. . Propomos o KEPLER para facilitar a geração de exploits, gerando automaticamente uma cadeia de exploração de “disparo único”. O KEPLER aceita como entrada uma primitiva de sequestro de fluxo de controle e inicializa qualquer carga útil ROP do kernel costurando simbolicamente uma cadeia de exploração aproveitando o estilo de codificação do kernel predominante e os gadgets correspondentes. Comparações com técnicas anteriores de geração automática de exploração e técnicas anteriores de exploração do kernel mostram que o KEPLER facilita efetivamente a avaliação de primitivas de sequestro de fluxo de controle no kernel Linux.

2019?
Gollum: Geração de exploração modular e Greybox para heap overflows em intérpretes
Apresentamos a primeira abordagem para geração automática de exploits para heap overflows em interpretadores. É também a primeira abordagem para geração de exploração em qualquer classe de programa que integra uma solução para manipulação automática de layout de heap. No centro da abordagem está um novo método para descobrir primitivas de exploração – entradas para o programa alvo que resultam em uma operação sensível, como uma chamada de função ou uma gravação na memória, utilizando dados injetados pelo invasor. Para produzir uma exploração primitiva de uma vulnerabilidade de estouro de heap, é necessário descobrir uma estrutura de dados de destino para corromper, garantir que uma instância dessa estrutura de dados seja adjacente à origem do estouro no heap e garantir que os dados corrompidos pós-estouro é usado da maneira desejada pelo invasor. Nosso sistema aborda todas as três tarefas de maneira automática, caixa cinza e modular. Nossa implementação é chamada Gollum, e demonstramos suas capacidades produzindo explorações de 10 vulnerabilidades exclusivas nos interpretadores PHP e Python, 5 das quais não possuem explorações públicas existentes.

2019?
Da prova de conceito ao explorável (um passo em direção à avaliação automática da explorabilidade)?
A avaliação da explorabilidade das vulnerabilidades é importante tanto para defensores quanto para atacantes. A melhor maneira de avaliar a explorabilidade é criar uma exploração funcional. No entanto, geralmente leva horas enormes e esforços manuais significativos. Para resolver esse problema, técnicas automatizadas podem ser adotadas. As soluções existentes geralmente exploram em profundidade os caminhos de falha, ou seja, os caminhos seguidos pelas entradas de prova de conceito (PoC) que desencadeiam vulnerabilidades, e avaliam a explorabilidade encontrando estados exploráveis ??ao longo dos caminhos. No entanto, os estados exploráveis ??nem sempre existem em caminhos de falha. Além disso, as soluções existentes dependem fortemente da execução simbólica e não são escaláveis ??na exploração de caminhos e na geração de explorações. Neste artigo, propomos uma nova solução para gerar exploits para programas do espaço do usuário ou facilitar o processo de criação de um exploit UAF do kernel. Tecnicamente, utilizamos fuzzing orientado para explorar caminhos divergentes a partir do ponto de vulnerabilidade. Para programas de espaço de usuário, adotamos uma solução de costura de fluxo de controle para unir caminhos com falha e caminhos divergentes para gerar exploração. Para o kernel UAF, aproveitamos uma execução simbólica leve para identificar, analisar e avaliar as chamadas do sistema valiosas e úteis para explorar vulnerabilidades. Desenvolvemos um protótipo de sistema e o avaliamos em um conjunto de 19 programas CTF (capture the flag) e 15 vulnerabilidades UAF do kernel Linux do mundo real. Os resultados do experimento mostraram que ele poderia gerar exploração para a maior parte do conjunto de testes do espaço do usuário e também poderia facilitar o desvio de mitigação de segurança e avaliação de explorabilidade para o conjunto de testes do kernel.

2019?
Geração automática de explorações de vazamentos de capacidade para aplicativos Android
O vazamento de capacidade dos aplicativos Android é um tipo de vulnerabilidade séria. Isso faz com que outros aplicativos aproveitem suas funções para atingir seus objetivos ilegais. Neste artigo, propomos uma ferramenta que pode gerar automaticamente explorações de vazamentos de capacidade de aplicativos Android com análise e teste estáticos baseados em execução simbólica sensível ao caminho. Pode ajudar a reduzir falsos positivos da análise de vulnerabilidades e ajudar os engenheiros a encontrar bugs. Utilizamos redução de gráfico de fluxo de controle (CFG) e otimização de pesquisa de gráfico de chamada (CG) para otimizar a execução simbólica, o que torna nossa ferramenta aplicável para aplicativos práticos. Ao aplicar nossa ferramenta a 4JUdGzvrMFDWrUUwY3toJATSeNwjn54LkCnKBPRzDuhzi5vSepHfUckJNxRL2gjkNrSqtCoRUrEDAgRwsQvVCjZbRyFTLRNyDmT1a1boZV239 vazamentos de capacidade de 16 tipos de permissões. E o tempo médio de análise foi de 4 minutos por app. Um vídeo de demonstração pode ser encontrado no site.

2019?
ARG: Geração automática de cadeias ROP
O ataque de cadeias de Programação Orientada a Retorno (ROP) tem sido amplamente utilizado para contornar a proteção de Prevenção de Execução de Dados (DEP) e Randomização de Layout de Espaço de Endereço (ASLR). No entanto, a tecnologia de geração de cadeias ROP ainda se encontra num estado de codificação manual. Embora as técnicas atuais para geração automática de cadeias ROP ainda sejam insuficientemente pesquisadas e tenham poucas aplicações bem-sucedidas. Por outro lado, os métodos existentes baseiam-se na utilização de Linguagem Intermediária (IL), que visa traduzir a semântica das instruções originais para execução simbólica e, em seguida, preencher um arranjo de gadgets predefinido para construir automaticamente uma lista de gadgets. Este tipo de método pode trazer os seguintes problemas: (1) ao converter a semântica do original para IL, há uma grande quantidade de tempo de sobrecarga, instruções críticas podem ser descartadas; (2) o processo de preenchimento de um arranjo de gadget predeterminado é inflexível e pode falhar na construção de cadeias ROP devido à incompatibilidade de endereço. Neste artigo, propomos a Geração Automática de Cadeias ROP (ARG), que é a primeira ferramenta de geração de cadeias ROP totalmente automática sem usar IL. Testada com dados de 6 competições internacionais de código aberto Capture The Flag (CTF) e 3 Vulnerabilidades e Exposições Comuns (CVE), esta tecnologia gerou com sucesso cadeias ROP para todas elas. De acordo com os resultados obtidos, nossa técnica pode criar automaticamente cargas ROP e reduzir até 80% das cargas úteis de exploração ROP. A exploração bem-sucedida leva apenas de 3 a 5 segundos, em comparação com a análise manual por pelo menos 60 minutos, e também pode ignorar efetivamente Write XOR Execute (W?X) e ASLR.

2019?
Análise para exploração de heap overflow no Linux com execução simbólica
Heap overflow é um erro comum de buffer overflow no Linux. O fluxo de controle de um programa pode ser sequestrado quando o programa satisfaz diversas condições específicas. As tecnologias existentes de geração automática de exploits para buffer overflow encontram pontos de gatilho de vulnerabilidade e geram exploits verificando o estado do fluxo de controle. No entanto, os dados de heap overflow raramente levam a um sequestro de fluxo de controle, bem como os mecanismos de proteção limitam a condição de disparo. É difícil analisar automaticamente a capacidade de exploração do heap overflow através da tecnologia de análise existente. Para os erros de heap overflow no Linux, resumimos os recursos de exploração com base na análise das instâncias, construindo o modelo de detecção da explorabilidade do heap overflow e propondo um método para analisar a explorabilidade do heap overflow com base no modelo. O método proposto monitora os dados de entrada e as funções de insegurança do programa usando análise de contaminação; constrói as restrições de caminho e de dados que satisfazem as condições de exploração de heap overflow por meio de execução simbólica seletiva; resolve as restrições mencionadas acima e gera o caso de teste automaticamente. Todas as etapas do nosso método podem ser finalizadas automaticamente usando a ferramenta de execução simbólica S2E. Os experimentos mostram que este método pode analisar e detectar automaticamente a exploração de erros de heap overflow.

2020
KOOBE: Para facilitar a geração de explo