Firefox CVE-2024-9680

CVE-2024-9680

Descrição

Um atacante conseguiu alcançar a execução de código no processo de conteúdo ao explorar um use-after-free (uso após liberação) em timelines de animação (Animation timelines). Recebemos relatos de que essa vulnerabilidade está sendo explorada na natureza. Essa vulnerabilidade afeta Firefox < 131.0.2, Firefox ESR < 128.3.1, Firefox ESR < 115.16.1, Thunderbird < 131.0.1, Thunderbird < 128.3.1 e Thunderbird < 115.16.0.

tl;dr (Versão em Vídeo)

Créditos: Fireship

Exploração de Use-After-Free?!

Uma vulnerabilidade de "use-after-free" (uso após liberação) é um tipo de problema de corrupção de memória que ocorre quando um programa continua a usar um ponteiro (ou referência) para a memória depois que ela foi liberada (desalocada). Essa é uma condição perigosa porque a memória em questão não é mais de propriedade do programa, o que significa que ela pode ser reatribuída para outro propósito ou alterada por outras partes do programa. Se o programa continuar a usar essa memória liberada, isso pode levar a um comportamento imprevisível, incluindo travamentos, corrupção de dados ou exploração por atacantes.

Detalhamento da Vulnerabilidade:

1. Alocação e Desalocação de Memória:

   • Em muitas linguagens de programação, especialmente aquelas como C e C++, a memória é gerenciada manualmente. Os desenvolvedores alocam memória quando precisam dela (por exemplo, com funções como malloc() ou new) e a liberam quando terminam de usá-la (por exemplo, com free() ou delete).

2. O Problema:

   • Um problema de use-after-free surge quando um ponteiro ainda aponta para memória que já foi liberada. Se o programa posteriormente tentar ler ou escrever nessa memória, coisas inesperadas podem acontecer porque a memória pode agora estar realocada para outra parte do programa, alterada ou até mesmo não estar mais disponível para uso seguro.

3. Consequências:

   • Travamento (Crash): O programa pode tentar acessar memória inválida ou corrompida, levando a um travamento.
   • Corrupção de Dados: O programa pode, sem intenção, sobrescrever ou ler dados não pretendidos, causando corrupção.
   • Exploração de Segurança: Atacantes podem explorar vulnerabilidades de use-after-free manipulando o espaço de memória do programa. Por exemplo, se um atacante conseguir alocar dados controlados na memória liberada, ele pode potencialmente executar código arbitrário, alterar o fluxo de execução do programa ou obter acesso não autorizado.

Cenário de Exemplo:

Considere um exemplo simplificado em C:

#include <stdlib.h>
#include <stdio.h>

int main() {
    int *ptr = (int *)malloc(sizeof(int)); // Allocate memory
    *ptr = 42;                             // Use the allocated memory
    free(ptr);                             // Free the memory

    // Use the pointer after freeing the memory (use-after-free)
    printf("%d\n", *ptr);                  // Undefined behavior, potential crash or exploit
    return 0;
}

No exemplo:

• A memória é alocada para um inteiro, e o valor 42 é atribuído a ela.
• A memória é então liberada com free(ptr).
• Após liberar a memória, o ponteiro ptr ainda está sendo usado (desreferenciado na instrução printf()), o que leva a um comportamento indefinido. A memória pode ter sido reatribuída, e acessá-la pode levar a um travamento ou, em um cenário mais perigoso, à exploração do programa.

Potencial de Exploração:

Atacantes podem explorar vulnerabilidades de use-after-free manipulando cuidadosamente o gerenciamento de memória. Veja como um atacante poderia potencialmente usar essa vulnerabilidade:

1. Realocação de Memória: Depois que a memória é liberada, se o atacante puder controlar quais dados são colocados nessa memória liberada, ele pode fazer o programa usar esses novos dados no lugar dos dados originais.
2. Injeção de Código: Em certos casos, o atacante pode injetar código malicioso no local de memória, permitindo-lhe sequestrar o fluxo de controle do programa, levando à execução remota de código ou à escalada de privilégios.

Mitigações:

Para prevenir vulnerabilidades de use-after-free, os desenvolvedores podem:

• Definir ponteiros como NULL após liberá-los: Isso garante que, se um ponteiro for usado acidentalmente após ser liberado, o programa trave de forma mais previsível ou se comporte de maneira controlada, em vez de acessar memória inválida.
• Ponteiros inteligentes (smart pointers): Em linguagens como C++, usar ponteiros inteligentes (por exemplo, std::shared_ptr, std::unique_ptr) pode ajudar a gerenciar a memória automaticamente, reduzindo as chances de mau gerenciamento manual da memória.
• Verificação de limites e sanitizadores: Use ferramentas como o AddressSanitizer (ASan), que ajudam a detectar condições de use-after-free durante o desenvolvimento.

Como a Timeline de Animação CSS Explorou a Falha

Neste caso específico, a Timeline de Animação CSS—que é responsável por controlar o tempo das animações em uma página web—estava interagindo com outros componentes do navegador de tal forma que um objeto vinculado à timeline da animação foi liberado, mas o navegador continuou a usá-lo.