.
Use-After-Free (UAF) é uma vulnerabilidade primitiva de corrupção de memória que continua a representar uma ameaça significativa para todos os tipos de software, desde sistemas operacionais até software de aplicativo. Essa falha crítica de segurança ocorre quando um componente de aplicativo tenta acessar dados em um endereço de memória que já foi liberado, daí o nome — use-after-free.
As vulnerabilidades do UAF podem levar à potencial exploração do software ou até mesmo ao comprometimento do sistema. Aqui está o que é a vulnerabilidade do UAF, por que isso acontece e como você pode proteger seu software contra uma vulnerabilidade do UAF.
O que é a vulnerabilidade Use-After-Free (UAF)?
Antes de mergulhar na vulnerabilidade Use-After-Free, vamos dar um passo atrás e entender alguns fundamentos do gerenciamento de memória. Quando um programa é executado, seus dados e códigos são carregados na memória.
O gerenciamento de memória é o processo de gerenciamento de como armazenar (chamado de alocação de memória) e remover (chamado de desalocação de memória) dados e códigos na memória de maneira otimizada. Os dois principais segmentos de memória onde os dados do programa são armazenados são a pilha e o heap.
Os programas podem receber espaço de memória estaticamente na pilha e dinamicamente na pilha. Uma vulnerabilidade use-after-free ocorre quando os programadores não gerenciam a alocação e desalocação de memória dinâmica adequadamente em seus programas. Isso significa que a classe UAF de vulnerabilidades é um tipo de exploração de heap. Para entender melhor essa vulnerabilidade, é importante ter um bom entendimento de como os ponteiros funcionam na programação.
Use-After-Free (UAF), como o nome sugere, é um tipo de vulnerabilidade de corrupção de memória primitiva que ocorre quando um objeto que já foi desalocado da memória é acessado novamente, levando a travamentos ou consequências não intencionais, como vazamentos de memória, Escalation of Privilege (EOP) ou execução arbitrária de código. Vamos aprender como essa condição ocorre em primeiro lugar e como ela é explorada.
Como o Use-After-Free (UAF) é explorado?
Use-After-Free (UAF), como o nome sugere, é uma vulnerabilidade primitiva de corrupção de memória que ocorre quando um programa continua a acessar locais de memória que liberou. Vamos dar uma olhada em um código de exemplo:
#include <stdio.h>
#include <stdlib.h>int main() {
int *Strong The One = malloc(sizeof(int));
*Strong The One = 69420;
printf("Value: %dn", *Strong The One);
free(Strong The One);
printf("Value?: %dn", *Strong The One);
return 0;
}
Poderia detectar a vulnerabilidade? Como você pode ver, neste código, o Strong The One ponteiro é desalocado da memória usando o livre() função, mas é chamado novamente na próxima linha usando o printf() função. Isso resulta em um comportamento inesperado do programa e, dependendo de onde a vulnerabilidade está presente no software, ela pode ser aproveitada para obter escalonamento de privilégios e vazamentos de memória.
Como Mitigar o Use-After-Free?
O UAF ocorre devido a erros na programação de um aplicativo. Existem algumas precauções que você pode tomar para evitar vulnerabilidades Use-After-Free em seu software.
Aqui estão algumas práticas recomendadas que você pode adotar para minimizar as vulnerabilidades de corrupção de memória em seu software:
- Usando linguagens de programação seguras para memória como Rust com mecanismos embutidos para evitar vulnerabilidades primitivas de corrupção de memória como UAF, Buffer Overflows, etc. Se você usa linguagens de programação como C/C++, é mais provável que introduza bugs de memória em seu código. Pelo mesmo motivo, até sistemas operacionais como Windows e Linux estão migrando lentamente para o Rust. Você também deve considerar aprender sobre Rust se criar programas de baixo nível.
- Além de usar uma linguagem segura para a memória, é recomendável seguir as práticas recomendadas, como definir um ponteiro para o valor NULL depois que ele for liberado para evitar qualquer introdução de vulnerabilidade Use-After-Free.
- Você também pode implementar técnicas como One Time Allocation (OTA) que impedem que invasores acessem objetos de memória liberados e uma Strict Object Lifecycle Policy, que ajuda a acompanhar cada objeto de memória alocado e desalocado. Lembre-se, porém, de que essas implementações podem aumentar a sobrecarga de memória e desempenho.
Exemplos do mundo real de vulnerabilidade Use-After-Free (UAF)
A vulnerabilidade Use-After-Free (UAF) foi descoberta e explorada em vários cenários do mundo real, desde navegadores da Web até o kernel do Android e aplicativos do dia a dia. Isso mostra a necessidade de medidas de segurança proativas. Alguns exemplos do mundo real de UAF incluem:
- Navegadores da Internet: vulnerabilidades UAF em navegadores da Web foram exploradas para executar código arbitrário, comprometer a privacidade do usuário e executar ataques de execução remota de código. Um exemplo recente seria o CVE-2021-38008, que explorou uma vulnerabilidade UAF no Google Chrome, permitindo que os agentes de ameaças executassem código arbitrário remotamente na máquina da vítima.
- Sistemas operacionais: as vulnerabilidades do UAF encontradas nos kernels do Windows/Linux/Android permitiram que os invasores obtivessem privilégios elevados, contornassem os mecanismos de segurança e ganhassem persistência. Há uma infinidade de vulnerabilidades UAF que foram encontradas e ainda são encontradas nos kernels do sistema operacional até esta data. No momento da redação deste artigo, CVE-2023-3269, outra vulnerabilidade do UAF no kernel do Linux que leva ao escalonamento de privilégios foi lançada publicamente. CVE-2022-23270 é um exemplo de vulnerabilidade UAF no kernel do Windows.
- Aplicativos de software: as vulnerabilidades UAF em aplicativos de software foram exploradas para manipular o comportamento do programa, levando à divulgação de informações, execução arbitrária de código, travamento do programa e, no pior dos casos, escalonamento de privilégios. Vários aplicativos de software foram e ainda são suscetíveis a ataques UAF. Esses softwares são principalmente programas C/C++ que foram desenvolvidos com abordagens de gerenciamento de memória ineficientes e inseguras.
Para saber mais sobre as vulnerabilidades Use-After-Free em aplicativos do mundo real, você pode verificar a página oficial da lista MITRE CVE e classificar por palavra-chave Use-After-Free.
Alocação eficiente de memória ajuda a tornar o software seguro
A alocação de memória ideal e bem pensada ajuda muito a proteger seus aplicativos de serem vítimas de vulnerabilidades comuns de corrupção de memória primitiva.
UAF junto com Time Of Check Time of Use (TOCTOU), condições de corrida e Buffer Overflows (BOF) são algumas das vulnerabilidades de memória mais comumente exploradas. Tudo isso pode ser evitado aprendendo como a memória do seu programa é gerenciada pela plataforma em que ele é executado. Isso lhe dá clareza de como o sistema operacional está alocando seu programa na memória e o equipa com as ferramentas para projetar software para desempenho e segurança ideais.
Se ainda não o fez, você pode começar entendendo como o gerenciamento de memória é feito no Linux, o sistema operacional de servidor mais usado no mundo.
.
