Software Security Characterization through Static Data Analysis

Abstract

Modern enterprises rely on software systems to run their business: financial, healthcare, government, and e-commerce, among many others. However, many systems are deployed with vulnerabilities caused by a design flaw or an implementation bug. The malicious exploitation of those security vulnerabilities may lead to various problems with financial or legal implications.Vulnerability detection techniques can be divided into two main groups: static techniques and dynamic techniques. The most known static technique is Static Code Analysis (SCA) that reports potential problems (alerts) without requiring the execution of the code. There are other more recent techniques, for example, based on ML, where static properties extracted from the source code are used as features to predict vulnerabilities. On the dynamic techniques, the most known is Software Penetration Testing (SPT) that simulates attacks in a controlled environment.Vulnerability detection techniques have strong limitations. Tools are frequently too expensive for most organizations, and they either report many false positives or false negatives. Consequently, developers are required to spend a considerable amount of time analyzing the reported cases without being sure that all vulnerabilities have been detected. This thesis advances the state-of-the-art on the characterization of software code units from a security vulnerability perspective, making use of static data from the source code.The first contribution is a dataset of static data on vulnerability fixes. This dataset includes vulnerabilities from five open-source C/C++ projects (Linux Kernel, Mozilla, Xen, Apache httpd, and glibc), and static data (Software Metrics (SMs) and alerts from Static Analysis Tools (SATs)) extracted from the vulnerable and neutral versions of the code. Vulnerabilities are organized into categories, devised based on the improper or lack of use of the OWASP best practices.To better understand static vulnerability detection, we present two studies. In the first, vulnerabilities from the Mozilla project are used to study the performance of SATs in detecting different types of software vulnerabilities. Results confirm that none of the SATs used (CppCheck and Flawfinder) can be trusted, as they fail to detect a large number of vulnerabilities while raising a large number of false positives. Developing on these observations, in the second study, we analyze the characteristics of a set of buffer overflow vulnerabilities from the Linux Kernel, Mozilla, and Xen projects, using both static data and a classification of the vulnerabilities with ODC. The main findings are that there is no strong correlation between the static information considered and the occurrence of vulnerabilities and that fixing overflow vulnerabilities typically increases the code size and complexity.Pursuing the use of ML to detect vulnerabilities, we present two studies. In the first one, classical ML algorithms are used to predict the presence of vulnerabilities in files of the Mozilla project. Both SMs and SAT alerts are used as features for the ML algorithms (DT, RF, XGB, and Bagging). In the second, we follow an approach based on deep learning to detect vulnerabilities, grounded on DGCNN and VGG networks. In this case, features extracted from the CFG of functions of the Linux Kernel project are used. We conclude that none of the ML approaches considered can predict software vulnerabilities with acceptable performance. In fact, although we can obtain good precision and good recall in some cases, no configuration allowed us to obtain both simultaneously.The low performance of SATs and ML observed in the studies above led us in a different direction. The Security Characterization of Open-source functions using Logic Scoring of Preference (SCOLP) allows categorizing code units using static information, including SMs and memory management-related attributes extracted from the CFG. In practice, SCOLP assigns the code units into priority groups, from most critical to least critical, based on the output of a set of QMs focusing on different properties. We demonstrate the approach with functions of the Linux Kernel project and rely on the judgment of security experts to validate the outputs. Results show that SCOLP provides categorizations similar to security experts.The last contribution is the Trustworthiness Monitoring & Assessment (TMA) framework, which brings self-adaptation abilities to software systems. TMA relies on QMs to characterize properties of interest regarding the managed system. The integration with the managed system happens through probes and actuators. The framework can be used at design-time (e.g., to collect security evidence) and at run-time (to detect and mitigate potential issues; e.g., intrusions). To demonstrate TMA, we present a scenario of scaling containers in a microservice application.

As empresas modernas dependem de sistemas de software para gerir os negócios nas diversas áreas.No entanto, muitos sistemas são implantados com vulnerabilidades causadas por uma falha de design ou defeito de implementação.A exploração maliciosa dessas vulnerabilidades pode levar a vários problemas com implicações financeiras ou jurídicas.As técnicas de deteção de vulnerabilidades podem ser divididas em dois grupos: técnicas estáticas e dinâmicas.A técnica estática mais conhecida é a análise estática de código, que reporta possíveis problemas (alertas) sem requerer a execução do código.Existem outras técnicas mais recentes, p.e. baseadas em ML, onde propriedades estáticas extraídas do código-fonte são usadas como recursos para prever vulnerabilidades.Nas técnicas dinâmicas, a mais conhecida é baseada em testes de penetração, que simulam ataques em um ambiente controlado.As técnicas de deteção de vulnerabilidades existentes têm fortes limitações.As ferramentas são frequentemente dispendiosas para grande parte das organizações e reporta um elevado número de falsos positivos ou de falsos negativos.Consequentemente, os desenvolvedores são obrigados a gastar uma quantidade considerável de tempo a analisar alertas, sem ter certeza de que todas as vulnerabilidades foram detetadas.Esta tese avança o estado-da-arte na caracterização de unidades de código de uma perspetiva de vulnerabilidades de segurança, fazendo uso de dados estáticos extraídos do código-fonte.A primeira contribuição é um repositório de dados estáticos sobre correções de vulnerabilidades.Este repositório inclui vulnerabilidades de cinco projetos C/C++ de código aberto (Linux Kernel, Mozilla, Xen, Apache httpd, glibc) e dados estáticos (métricas de software e alertas de análise estática) extraídos das versões vulneráveis e neutras do código. As vulnerabilidades estão organizadas em categorias, definidas com base no uso impróprio ou na falta de uso das melhores práticas da OWASP.Para melhor compreender a deteção por análise estática, apresentamos dois estudos. No primeiro, as vulnerabilidades do projeto Mozilla são usadas para analisar o desempenho de analisadores estáticos na deteção de diferentes tipos de vulnerabilidades de software.Os resultados confirmam que nenhuma das ferramentas usadas (CppCheck e Flawfinder) é confiável, pois falham na deteção de um grande número de vulnerabilidades enquanto reportam um elevado número de falsos alertas.Com base nestas observações, no segundo estudo, analisamos as características de um conjunto de vulnerabilidades de buffer overflow dos projetos Linux Kernel, Mozilla e Xen, usando dados estáticos e uma classificação das vulnerabilidades com ODC.As principais descobertas são: i) não se observa uma forte correlação entre os dados estáticas consideradas e a ocorrência de vulnerabilidades, e ii) a correção de vulnerabilidades de buffer overflow normalmente aumenta o tamanho e a complexidade do código.Focando na utilização de ML para detetar vulnerabilidades, apresentamos dois estudos.No primeiro, usamos algoritmos clássicos para prever a presença de vulnerabilidades em ficheiros do projeto Mozilla. Métricas de software e alertas de análise estática são usados como recurso para os algoritmos de ML (DT, RF, XGB e Bagging).No segundo estudo, seguimos uma abordagem baseada em deep learning para detetar vulnerabilidades, assente em redes DGCNN e VGG.Neste caso, são utilizados recursos extraídos do CFG de funções do projeto Linux Kernel.Os estudos levam a concluir que nenhuma das abordagens consideradas é capaz de prever vulnerabilidades de software com desempenho aceitável.De facto, embora possamos obter uma boa precisão e uma boa sensibilidade em alguns casos, nenhuma configuração permitiu obter ambos em simultâneo.O baixo desempenho das abordagens baseadas em análise estática e em ML observado nos estudos acima, levou o trabalho a seguir uma direção diferente.A técnica SCOLP permite categorizar unidades de código usando informações estáticas, incluindo métricas de software e atributos relacionados à gestão de memória extraídos do CFG.Na prática, esta técnica distribui as unidades de código em grupos de prioridade, do mais ao menos crítico, com base no resultado de um conjunto de modelos de qualidade com foco em diferentes propriedades.A abordagem é demonstrada em funções do projeto Linux Kernel, tendo o julgamento de especialistas em segurança sido usado para validar as classificações.Os resultados mostram que o SCOLP fornece categorizações semelhantes às dos especialistas.A última contribuição é a plataforma TMA, que traz capacidades de auto-adaptação para software.A solução baseia-se em modelos de qualidade para caracterizar propriedades de interesse em relação ao sistema alvo.A integração com esse sistema dá-se através de sondas e atuadores. A plataforma pode ser usada em durante o desenho (para recolher evidências de segurança) e em tempo de execução (para detetar e mitigar potenciais problemas, p.e. intrusões).