A empresa Checkpoint é um mecanismo de proteção Safe-Linking, projetado para dificultar a criação de exploits que manipulam a definição ou a alteração de ponteiros para buffers alocados durante a chamada de malloc. O Safe-Linking não bloqueia totalmente a exploração de vulnerabilidades, mas aumenta significativamente a complexidade de criação de algumas categorias de exploits com um custo mínimo, uma vez que, além do estouro de buffer explorável, é necessário encontrar outra vulnerabilidade que provoque uma vazamento de informações sobre a alocação de heap na memória.
Os patches com a implementação do Safe-Linking foram preparados para Glibc (ptmalloc), uClibc-NG (dlmalloc), gperftools (tcmalloc) e Google TCMalloc, e também foram sugeridos para modernização da proteção no Chromium (em
O Chromium desde 2012 já possui uma técnica de proteção chamada MaskPtr, que visa resolver o mesmo problema, mas a solução da Checkpoint demonstra um desempenho superior).
Os patches sugeridos já foram aprovados para inclusão na versão de agosto e a implementação do Safe-Linking será incluída por padrão. No uClibc-NG, o suporte ao Safe-Linking está incluído na versão 1.0.33 e ativado por padrão. No gperftools (o antigo tcmalloc), as alterações , mas serão propostas em uma das próximas versões como uma opção.
Desenvolvedores (o novo tcmalloc) optou por não aceitar , citando uma drástica redução de desempenho e a necessidade de adicionar testes extensivos para verificar regularmente se tudo está funcionando corretamente. No entanto, os testes realizados pelos engenheiros da Checkpoint mostraram que o método Safe-Linking não resulta em um consumo adicional de memória, e o desempenho durante operações de heap, em média, diminui apenas 0,02%, e na pior das hipóteses, 1,5% (para comparação, os custos associados ao método usado no Chromium são estimados em "menos de 2%"). A inclusão
do Safe-Linking resulta em 2-3 instruções adicionais de assembly sendo executadas em cada chamada de free() e 3-4 instruções durante a chamada de malloc(). Não é necessário executar etapas de inicialização e geração de valores aleatórios.
O Safe-Linking pode ser aplicado não apenas para aumentar a segurança de várias implementações de heap, mas também para adicionar mecanismos de controle de integridade a quaisquer estruturas de dados que utilizem listas encadeadas de ponteiros, que são colocadas ao lado dos próprios buffers. O método é muito simples de implementar e requer apenas a adição de um macro e sua aplicação aos ponteiros do próximo bloco no código (por exemplo, para Glibc apenas algumas linhas no código). O método se resume às seguintes alterações:
+#define PROTECT_PTR(pos, ptr) \
+ ((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))
+#define REVEAL_PTR(ptr) PROTECT_PTR (&ptr, ptr)
— nextp = p->fd;
+ nextp = REVEAL_PTR (p->fd);
…
A essência do método está na aplicação de dados aleatórios do mecanismo de randomização de endereços ASLR (mmap_base) para proteger listas encadeadas, como Fast-Bins e TCache. Antes de aplicar ao valor do ponteiro para o próximo elemento na lista, é realizada uma transformação por máscara e verificação de alinhamento ao limite da página de memória. O ponteiro é substituído pelo resultado da operação «(L >> PAGE_SHIFT) XOR (P)», onde P é o valor do ponteiro, e L é a localização na memória onde esse ponteiro está armazenado.
Ao ser usado no sistema (Address Space Layout Randomization) parte dos bits L com o endereço base do heap contém valores aleatórios, que são usados como chave para codificar P (extraídos pela operação de deslocamento de 12 bits para páginas de 4096 bytes). Essa manipulação reduz o risco de captura do ponteiro em um exploit, uma vez que o ponteiro não é armazenado em sua forma original e para sua substituição é necessário conhecer informações sobre a alocação do heap. Além disso, o código do patch também inclui uma verificação adicional de alinhamento do bloco, que impede que um atacante substitua o ponteiro por um valor desalinhado e requer conhecimento do número de bits pelo qual o alinhamento foi feito, o que em sistemas de 64 bits adicionalmente bloqueia 15 de 16 tentativas de ataque que não consideram o alinhamento.
O método é eficaz para proteger contra ataques que utilizam a sobreposição parcial de ponteiros (modificação dos bytes menos significativos), a reescrita completa de ponteiros (redirecionamento para o código do atacante) e mudança de posição da lista em um endereço desalinhado. Como exemplo, foi mostrado que a aplicação do Safe-Linking no malloc poderia bloquear a exploração de uma recentemente as mesmas vulnerabilidades investigadas na iluminação inteligente do Philips Hue Bridge, causada por um buffer overflow, permitindo obter controle sobre o dispositivo.
Fonte: opennet.ru
