O que é uma vulnerabilidade Use-After-Free (UAF)?

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ódigo 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 segmentos primários de memória onde os dados do programa são armazenados são

a pilha e a pilha.

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, é útil ter um forte entendimento de como os ponteiros funcionam na programação.

Use-After-Free (UAF) como o nome sugere, é um tipo de vulnerabilidade primitiva de corrupção de memória que ocorre quando um objeto que já foi desalocado da memória é acessado novamente levando a falhas ou consequências não intencionais, como vazamentos de memória, Escalação de Privilégio (EOP) ou código arbitrário execução. 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:

#incluir <estúdio.h>
#incluir <stdlib.h>
intprincipal(){
int *MUO = malloc (tamanho(int));
 *MUO = 69420;
printf("Valor: %d\n", *MUO);
 grátis (MUO);
printf("Valor?: %d\n", *MUO);
retornar0;
}

Poderia detectar a vulnerabilidade? Como você pode ver, neste código, o MUO 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, estouros de buffer, 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 aprendendo sobre ferrugem se você 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 a memória liberada objetos e uma Política Estrita de Ciclo de Vida de Objetos, que ajuda a acompanhar cada objeto de memória que é 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 do UAF em aplicativos de software foram exploradas para manipular o programa comportamento, levando à divulgação de informações, execução de código arbitrário, travamento do programa e, no pior dos casos, privilégio escalação. 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 o oficial MITRE CVE página da lista e classifique 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.