dcheng69/cve-2022-0185-case-study
Este estudo de caso é resultado de um trabalho da disciplina ECE 9069: Introduction to Hacking : https://whisperlab.org/introduction-to-hacking/
O CVE-2022-0185 é uma falha de estouro de buffer baseado em heap, encontrada na forma como a função legacy_parse_param na funcionalidade Filesystem Context do kernel Linux verificava o comprimento dos parâmetros fornecidos. Um usuário local sem privilégios (no caso de namespaces de usuário sem privilégios habilitados, caso contrário precisa do privilégio CAP_SYS_ADMIN em namespace) capaz de abrir um sistema de arquivos que não suporta a API Filesystem Context (e, portanto, recorre ao tratamento legado) poderia usar essa falha para escalar seus privilégios no sistema. [1]
Depois que essa vulnerabilidade foi relatada, uma correção foi lançada para corrigir esse bug:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=722d94847de2
https://ubuntu.com/security/CVE-2022-0185#impact-score
Há uma análise detalhada do explorador: https://www.hackthebox.com/blog/CVE-2022-0185:_A_case_study
Neste repositório, explicarei as etapas básicas e as informações de contexto relacionadas para reproduzir essa vulnerabilidade. Além disso, se houver algo que você considere confuso, envie-me um e-mail para [email protected]. Ficarei muito feliz em responder às dúvidas.
A vulnerabilidade CVE-2022-0185 foi publicada em 02/11/2022, com uma pontuação base CVSS 3.x de 8,4 (Alta).[1] Essa vulnerabilidade é um estouro de buffer baseado em heap, causado por um underflow de inteiro sem sinal.
A vulnerabilidade foi introduzida no kernel Linux v5.1, afetando todas as distribuições Linux com versões de kernel superiores a 5.1. Por exemplo, o Ubuntu 20.04 LTS (focal) era vulnerável a esse bug. No entanto, uma correção foi lançada e está disponível desde a versão 5.4.0-96.109 .[3]
Explorar essa vulnerabilidade permite que um usuário local sem privilégios escale seus privilégios no sistema, potencialmente comprometendo todo o sistema.[1] [2] Aqui está uma análise detalhada da pontuação CVSS: Pontuação Base: 8,4, indicando um risco de segurança significativo que exige atenção imediata. Pontuação de Impacto: 5,9, sugerindo danos potenciais substanciais se explorado. Os altos valores de confidencialidade, integridade e disponibilidade contribuem para essa pontuação. Pontuação de Exploração: 2,5, sugerindo exploração relativamente alta. O vetor de ataque local, a alta integridade , e a alta disponibilidade contribuem para essa pontuação.
A Tabela 1.1 e a Tabela 1.2 fornecem mais informações sobre essas pontuações e seus componentes.
| Gravidade CVSS v3.1 | Valor |
|---|---|
| Pontuação Base | 8.4 ALTA |
| Pontuação de Impacto | 5.9 |
| Pontuação de Exploração | 2.5 |
Tabela 1.1 Pontuações de Gravidade CVSS[1]
Tabela 1.2 Vetor CVSS[1]
Existem dois tipos de inteiros em computadores modernos, com sinal e sem sinal. A representação de números com sinal geralmente envolve uma operação chamada complemento de dois.[4] “O complemento de dois usa o dígito binário com o maior valor posicional como sinal para indicar se o número binário é positivo ou negativo”[4]
A introdução do complemento de dois converte o cálculo da subtração em adição, simplificando assim o projeto e a implementação da CPU. A geração do complemento de dois de um inteiro envolve três etapas:[4]
A Fig 2.1.1.1 mostra o processo de conversão em um diagrama com um exemplo real de conversão de “-6” para o formato de complemento de dois.
Fig 2.1.1.2 Adição Usando o Complemento de Dois
A Figura 2.1.1.2 mostra o processo de adicionar o complemento de dois de '-6' a '+6'. Isso demonstra como o uso do complemento de dois permite que a adição seja usada como substituto da subtração.
Fig 2.1.1.2 Adição Usando o Complemento de Dois
Da Seção 2.1.1, já entendemos o que é o complemento de dois. Agora, vamos examinar o cenário de underflow de número sem sinal em computadores. Em computadores modernos, ao usar números sem sinal, o bit mais significativo não é tratado como um bit de sinal; em vez disso, ele faz parte do próprio número sem sinal. Essa situação significa que, ao realizar subtração com um número sem sinal, devemos ter cautela, pois isso pode levar a uma condição conhecida como underflow de número sem sinal.[5]
A Fig 2.1.2.1 ilustra a situação de subtrair 6 de 5 em um número sem sinal de 8 bits. O resultado final é 255, pois o número sem sinal dá a volta (wrap-around). Quando esse underflow ocorre em uma instrução condicional, ele tem o potencial de interromper a funcionalidade da instrução.
Fig 2.1.2.1 Underflow de Número sem Sinal
No kernel Linux, o Alocador Slab é um mecanismo de gerenciamento de memória usado para alocação e desalocação eficientes de pequenos blocos de memória. Ele proporciona desempenho mantendo vários caches de Slabs, cada um contendo blocos de memória de tamanho fixo. Normalmente, o kmalloc-32 aloca 32 bytes de memória, sendo um slab kmalloc-32, enquanto o kmalloc-4k aloca 4096 bytes de memória, sendo um slab kmalloc-4k.[6]
Além disso, a alocação de slabs no kernel Linux normalmente envolve alocar memória de um espaço de endereço contíguo dentro da região de memória heap do kernel. Esse endereço contíguo é gerenciado pelo kernel e é usado para alocar memória para vários objetos e estruturas de dados do kernel. A Fig 2.2.1.1 mostra o layout dos slabs na memória do kernel LInux.
Fig 2.2.1.1 Alocador Slab no Linux [7] (O autor desta figura é https://leviathan.vip/)
Se você quiser reproduzir o processo com um kernel linux compilado por conta própria, leia os seguintes arquivos markdown para obter as informações de contexto:
Nota:
Todos os arquivos markdown, bem como o código e os scripts, estão em diferentes pastas deste repositório; cada pasta vem com seu próprio arquivo markdown. Leia-o antes de tentar fazer qualquer coisa!
Na seção 2.1, explicamos como funciona o underflow sem sinal. Agora, examinaremos a função do kernel que contém essa vulnerabilidade.
O usuário “clubby789” descobriu uma vulnerabilidade na função do kernel legacy_parse_param . Essa função é responsável principalmente por analisar os parâmetros passados ao kernel. No CVE-2022-0185, ela era invocada após usar fsopen para abrir um descritor de arquivo, seguido pelo uso da função fsconfig para passar os pares chave-valor de configuração ao kernel. Uma versão simplificada de legacy_parse_param é mostrada no código a seguir. [2]```c static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param) { struct legacy_fs_context *ctx = fc->fs_private; // [1] unsigned int size = ctx->data_size; // [2] size_t len = 0; int ret; [ ... ] switch (param->type) { case fs_value_is_string: len = 1 + param->size; // [3] case fs_value_is_flag: len += strlen(param->key); break; default: return invalf(fc, "VFS: Legacy: Parameter type for '%s' not supported", param->key); } if (len > PAGE_SIZE-2-size) return invalf(fc, "VFS: Legacy: Cumulative options too large"); // [4] [ ... ] if (!ctx->legacy_data) { ctx->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL); // [5] if (!ctx->legacy_data) return -ENOMEM; } ctx->legacy_data[size++] = ','; // [6] len = strlen(param->key); memcpy(ctx->legacy_data + size, param->key, len); size += len; if (param->type == fs_value_is_string) { ctx->legacy_data[size++] = '='; memcpy(ctx->legacy_data + size, param->string, param->size); size += param->size; } ctx->legacy_data[size] = '\0'; ctx->data_size = size; ctx->param_type = LEGACY_FS_INDIVIDUAL_PARAMS; return 0; }
A partir do trecho de código acima, podemos ver que as linhas [1] e [2] definem o contexto do código, enquanto a linha [4] contém a declaração onde ocorre o underflow sem sinal. A linha [5] lida com a alocação de slab no heap, e as linhas [6] e [7] são responsáveis por preencher dados no slab alocado. Notavelmente, a linha [6] adiciona uma vírgula (',') como delimitador separado, e um sinal de igual ('=') também é adicionado, resultando em dois bytes extras além do tamanho real dos dados.
Na linha [4], as variáveis dentro da instrução if contêm PAGE_SIZE (uma macro definida como 4096) e size (um número sem sinal de 64 bits). Quando um número sem sinal acumula até 4095, ocorre underflow, fazendo com que a instrução if seja sempre avaliada como falsa. Isso permite uma escrita fora dos limites no slab vizinho. O underflow é causado pela subtração de um número sem sinal, resultando em 4096 - 4095, o que produz um número sem sinal de 18446744073709551615.[2]
O resultado de `18446744073709551615` é explicado no texto a seguir:```c
if (len > PAGE_SIZE-2-size) return invalf(fc, "VFS: Legacy: Cumulative options too large");
Observe que, aqui, o PAGE_SIZE é igual a 4096 bytes, e o 2 é igual ao caractere , e = adicionados para separar cada par key-value. O problema é que size é um valor sem sinal; assim, quando size atinge 4095, a expressão PAGE_SIZE-2-size será igual a singned value: -1, porém, para valor sem sinal: 18446744073709551615 por causa do complemento de 2, como mostrado no diagrama a seguir! [3]
Portanto, a instrução if acima sempre será falsa, o que significa que o restante dos dados será copiado para o heap além do slab que alocamos!
Depois de entender como esse underflow de número sem sinal pode ocorrer, podemos prosseguir para construir um código de prova de conceito (POC) para demonstrar a vulnerabilidade.
O usuário “clubby789” nos fornece um código POC detalhado, mostrado no trecho de código a seguir. O código é conciso; ele primeiro abre um descritor de arquivo chamado ext4 e depois usa fsconfig várias vezes para popular dados no kernel.
Duas coisas a observar aqui:
Na seção 3.1.1, mencionamos que 4095 bytes de dados precisam ser preenchidos antes de observar a gravação fora dos limites. Como cada ciclo preenche apenas 35 bytes, devemos executar a operação 117 vezes (4095 / 35) antes de observar a memória do heap para concluir a prova de conceito.
### 3.1.3 POC com QEMU
Neste repositório: GitHub - dcheng69/CVE-2022-0185-Case-Study, fornecemos um script de shell chamado poc.sh para facilitar o processo de depuração. Leia o arquivo markdown na pasta Poc antes de iniciar a configuração.
Como legacy_parse_param é uma função do kernel, você precisará depurar uma função do kernel. Para isso, é necessário compilar o código-fonte do kernel para obter os símbolos e o código-fonte necessários. Também fornecemos um arquivo markdown detalhado para orientá-lo no processo. Consulte a pasta Compile_linux para mais detalhes.
Na Fig. 3.1.3.1, demonstramos que, após preencher 4095 bytes de dados no heap do kernel, conseguimos acionar uma gravação fora dos limites explorando o underflow sem sinal. Além disso, preenchemos um total de 4130 bytes de dados em um slab kmalloc-4k, corrompendo com êxito o slab vizinho. Embora neste exemplo o slab vizinho não contenha informações (todos os zeros), podemos construir cuidadosamente nosso código para aproveitar esse recurso e escrever dados maliciosos. Demonstraremos como alcançar isso na seção 3.2 Exploit.
**Fig 3.1.3.1 POC com QEMU**
Para mais detalhes, consulte https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/Poc/poc.md na pasta `Poc` deste repositório!
## 3.2 Exploit
Depois de conhecer esta vulnerabilidade, podemos avançar para usá-la para realizar um exploit, cujos detalhes estão documentados na pasta `exploit-ubuntu` e também neste arquivo markdown: https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/explot-ubuntu/exploit.md
Em suma, compilamos o código-fonte do Ubuntu, obtemos o arquivo deb e o testamos em uma máquina virtual para obter uma versão específica do kernel. Em seguida, modificamos o offset do código do exploit para atingir a versão do kernel usando as informações encontradas no arquivo `System.map`. Por fim, atualizamos o grub e reiniciamos para explorar!
### 3.2.1 Visão Geral do Exploit
O usuário 'clubby789' nos fornece um código de exploit detalhado. Começaremos com uma visão geral, seguida de explicações de vários conceitos-chave usando diagramas. Por fim, apresentaremos os resultados do exploit usando o Ubuntu em execução em uma máquina virtual (VirtualBox).
Após demonstrar a prova de conceito desta vulnerabilidade, podemos agora prosseguir para explorá-la. Na Fig. 3.2.1.1, é ilustrada uma visão geral de como explorar esta vulnerabilidade:
- A seção esquerda concentra-se em obter o endereço base do kernel Linux. Isso é alcançado explorando o underflow sem sinal para sobrescrever o campo m_ts da estrutura msg_msg, permitindo-nos ler fora dos limites e acessar estruturas do kernel previamente pulverizadas na memória.
- A seção direita tem como objetivo obter privilégios de root. Isso é feito usando underflow sem sinal para sobrescrever o ponteiro next da estrutura msg_msg, apontando-o para modprobe_path. Em seguida, acionamos uma falta de página (page fault) que invoca o nosso código FUSE construído, permitindo gravações arbitrárias no espaço do kernel.
**Fig 3.2.1.1 Visão geral do Exploit**
### 3.2.2 Obter o Endereço Base do Kernel Linux
Como analisado anteriormente, exploraremos o underflow sem sinal nesta parte para sobrescrever o campo m_ts da estrutura msg_msg, permitindo uma leitura fora dos limites. Ao pulverizar o heap com estruturas que contêm ponteiros do kernel, podemos, com sorte, obter um vazamento de memória.
A struct msg_msg é uma estrutura de dados no kernel Linux usada para implementar filas de mensagens do System V. Nesta seção, focamos na estrutura interna da struct msg_msg e na lógica das funções relacionadas ao envio, recebimento e alocação de mensagens. Como mostrado na Fig. 3.2.2.1, essas são as funções que precisamos entender.
A struct msg_msg é uma estrutura de dados no kernel Linux usada para implementar filas de mensagens do System V.[8] Nesta discussão, focamos na estrutura interna da struct msg_msg, juntamente com a lógica das funções relacionadas ao envio, recebimento e alocação de mensagens. Como mostrado na Fig. 3.2.2.1, essas são as funções que precisamos entender."
A implementação do envio de mensagens está localizada no arquivo msg.c, que define o comprimento máximo de uma mensagem como 8192 bytes. Na função alloc_msg, as mensagens são divididas em segmentos com base em seu comprimento. Se o comprimento da mensagem, juntamente com o cabeçalho da mensagem, exceder uma página (4096 bytes), a mensagem será armazenada em vários segmentos ligados entre si por ponteiros.
**Fig 3.2.2.1 struct msg_msg envio e recebimento**
Na Fig. 3.2.2.2, podemos ver que a struct msg_msg serve como cabeçalho de mensagem, ocupando 0x30 bytes de memória. Se houver dados residuais na mensagem, eles serão armazenados em segmentos de mensagem e vinculados à struct msg_msgseg. Portanto, se o kernel permitir mensagens de até 8192 bytes no máximo, os dados serão armazenados em, no máximo, três segmentos de mensagem.
**Fig 3.2.2.2 struct msg_msg**
Na Fig. 3.2.2.3, ilustramos a estrutura da struct msg_msg. Pelo código, sabemos que o campo m_ts é o que precisamos sobrescrever para ler fora dos limites. (Você pode encontrar o arquivo-fonte draw.io na pasta `res` se precisar!)
**Fig 3.2.2.2 estrutura da struct msg_msg**
Agora que entendemos a estrutura da struct msg_msg, precisamos aprender como obter um vazamento do kernel. O kernel Linux possui um recurso de Randomização do Layout do Espaço de Endereço do Kernel (KASLR), o que significa que o código do kernel é carregado em um endereço aleatório decidido durante a fase de inicialização. No entanto, o deslocamento (offset) do ponto inicial do kernel até o endereço de qualquer função permanece constante, permitindo-nos realizar operações específicas para preencher o espaço do heap com estruturas que contêm funções específicas do kernel. Ao diminuir o offset, podemos encontrar o endereço inicial do kernel.
Felizmente, podemos pulverizar facilmente o heap com estruturas seq_operations abrindo /proc/self/stat, que reside em slabs kmalloc-32. A definição de seq_operations é mostrada na Fig. 3.2.2.3.
**Fig 3.2.2.3 Estruturas para vazamento do kernel**
Por fim, o processo geral é representado na Fig. 3.2.2.4. Começamos preenchendo o legacy_data com 4095 bytes de dados para nos preparar para a sobrescrita. Em seguida, construímos mensagens usando a struct msg_msg. Como a memória do heap é alocada continuamente, as mensagens construídas provavelmente estarão adjacentes ao slab kmalloc-4k vizinho. Sobrescrevemos o campo m_ts controlando os dados que escrevemos no legacy_data.
Em seguida, pulverizamos o heap com várias estruturas seq_operations kmalloc-32. Depois, recebemos dados da fila de mensagens, o que aciona uma leitura fora dos limites. Ao ajustar o offset a partir da função do kernel, podemos obter o endereço base do kernel.
**Fig 3.2.2.3 Visão geral da leitura fora dos limites**
### 3.2.3 Obter Privilégio de Root
Semelhante à nossa análise anterior, nesta parte precisamos configurar um sistema de arquivos FUSE, que permite que nosso código no espaço do usuário trate faltas de página do espaço do kernel. Ao mesmo tempo, sobrescreveremos o ponteiro *next de msg_msgseg para apontar para modprobe_path, permitindo gravações arbitrárias no espaço do kernel.
Vamos primeiro examinar a pilha de chamadas do FUSE representada na Fig. 3.2.3.1. Em geral, o FUSE nos permite implementar um sistema de arquivos no espaço do usuário. Quando há uma nova operação, o sistema invocará o código que definimos para o FUSE!
**Fig 3.2.3.1 Visão geral do FUSE**
Vamos analisar como usar o FUSE para alcançar gravações arbitrárias no espaço do kernel. Primeiro, vamos considerar a operação de envio de mensagens para a struct msg_msg. Essa operação envolve escrever dados no espaço do kernel. Se construirmos a mensagem com dois segmentos, podemos sobrescrever o ponteiro e gravar em qualquer endereço do kernel. Esse conceito é ilustrado na Fig. 3.2.3.2.
Além disso, após examinar a lógica de envio de mensagens para a fila, sabemos que o processo envolve copiar um buffer do espaço do usuário para o espaço do kernel. Se as mensagens forem longas o suficiente, elas serão copiadas segmento por segmento. Se pudermos acionar uma falta de página durante esse processo, poderemos alcançar o cenário mostrado na Fig. 3.2.3.2.
Felizmente, o FUSE fornece a funcionalidade necessária. Podemos mapear uma página para o FUSE e, quando uma falta de página é acionada, o sistema chamará nossa função de leitura do FUSE para tratar a falta de página. Ao pausar o processo de leitura até que o underflow sem sinal sobrescreva o ponteiro *next de msg_msg_seg e, em seguida, retomar o processo de envio de mensagens, podemos alcançar gravações arbitrárias. Todo o processo é demonstrado na Fig. 3.2.3.3.
**Fig 3.2.3.2 Usando o envio de mensagem**
**Fig 3.2.3.3 FUSE e envio de mensagem**
### 3.2.4 Exploit com virtual box
Seguindo o arquivo markdown de: https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/explot-ubuntu/exploit.md
Após a conclusão da compilação, você pode observar os resultados do exploit na Fig. 3.2.4.1.
**Fig 3.2.4.1 Exploit com VirtualBox**
# 4. Mitigação da Vulnerabilidade
## 4.1 Patches Oficiais
Após a divulgação desta vulnerabilidade, o Linux e suas muitas distribuições incorporaram correções (patches) para resolver esse bug.[9] [10] [11]
Na captura de tela a seguir, mostramos o patch incorporado por Linus Torvalds. A mitigação desse problema de underflow consiste simplesmente em converter a operação de subtração em adição.
# 5. Impacto no Mundo Real
Neste relatório, demonstramos como essa vulnerabilidade pode ser explorada para comprometer um sistema Ubuntu. Além disso, ela pode potencialmente atingir sistemas mais antigos que não recebem atualizações de segurança regulares.
Em relação ao Kubernetes, essa vulnerabilidade pode resultar em escalada de privilégios, fuga de contêineres ou ataques de negação de serviço.
Embora não tenham havido perdas relatadas na imprensa causadas por essa vulnerabilidade, ela ressalta a importância de aplicar consistentemente atualizações críticas de segurança. O pesquisador que relatou essa vulnerabilidade exemplifica as práticas de hacking ético que todos devemos nos esforçar para defender.[12]
# Referência
[1] https://nvd.nist.gov/vuln/detail/CVE-2022-0185
[2] https://www.hackthebox.com/blog/CVE-2022-0185:_A_case_study
[3] https://ubuntu.com/security/CVE-2022-0185#impact-score
[4] [https://en.wikipedia.org/wiki/Two%27s_complement](https://en.wikipedia.org/wiki/Two's_complement)
[5]https://www.gnu.org/software/c-intro-and-ref/manual/html_node/Unsigned-Overflow.html
[6] https://www.kernel.org/doc/gorman/html/understand/understand011.html
[7] https://leviathan.vip/
[8] https://www.willsroot.io/2021/08/corctf-2021-fire-of-salvation-writeup.html
[9] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=722d94847de2
[10] https://ubuntu.com/security/CVE-2022-0185
[11] https://access.redhat.com/security/cve/CVE-2022-0185
[12]https://jfrog.com/blog/the-impact-of-cve-2022-0185-linux-kernel-vulnerability-on-popular-kubernetes-engines/
[14] https://github.com/chenaotian/CVE-2022-0185?tab=readme-ov-file
[15] https://www.tutorialspoint.com/two-s-complement
| Métricas CVSS v3.1 | Valor |
|---|
| Vetor de Ataque (AV) | Local |
| Privilégios Necessários (PR) | Nenhum |
| Interação do Usuário (UI) | Nenhum |
| Confidencialidade (C) | Alta |
| Integridade (I) | Alta |
| Disponibilidade (A) | Alta |