Sanitizador de endereço kernel (KASAN)

O Kasaner (Kernel Address Sanitizer) é uma tecnologia de detecção de bugs com suporte em drivers de kernel do Windows que permite detectar várias classes de acessos ilegais à memória, como estouros de buffer e eventos de uso após liberação. Ele requer que você habilite o KASAN em seu sistema e recompile o driver do kernel com um sinalizador de compilador MSVC específico.

Pre-requisites

Para usar o KASAN, você precisa:

• Versão do sistema operacional do sistema de destino, no qual o driver do kernel será carregado:
  • Cliente: Windows 11 24H2 ou superior.
  • Servidor: Windows Server 2025 ou superior.
• VisualStudio: versão 17.11 ou superior.
• WDK: versão 10.0.26100.2161 ou superior.

O KASAN é suportado apenas em x64.

Como habilitar o KASAN no driver do kernel

1. Insira a seguinte linha de comando em uma janela do Prompt de Comando do administrador no sistema de destino:

   reg add "HKLM\System\CurrentControlSet\Control\Session Manager\Kernel" /v KasanEnabled /t REG_DWORD /d 1
   

   Definir essa chave do registro instrui o kernel do Windows a se preparar para e aceitar o carregamento de drivers instrumentados pelo KASAN. Não definir essa chave do Registro faz com que o kernel do Windows se recuse a carregar drivers instrumentados pelo KASAN.

2. Reinicialize o sistema de destino para que a alteração entre em vigor.

3. Recompile o driver do kernel com a instrumentação KASAN habilitada passando um novo sinalizador para o compilador MSVC. Use um dos seguintes métodos:

   • GUI: no VisualStudio, navegue até o Gerenciador de Soluções, clique com o botão direito do mouse no projeto do driver do kernel e selecione Propriedades. Na página de propriedades, navegue até as Propriedades>> de ConfiguraçãoC/C++>>Geral e defina Habilitar Sanitizador de Endereço kernel como Sim. Em seguida, recompile sua solução.
   • Prompt de comando: adicione o parâmetro /fsanitize=kernel-address à linha de comando do compilador. Em seguida, recompile sua solução.

4. Carregue o driver do kernel recompilado no sistema de destino e teste-o como faria normalmente. O KASAN opera em tempo de execução e relata eventos ilegais de acesso à memória por meio do 0x1F2 de verificação de bugs: KASAN_ILLEGAL_ACCESS.

Regressão no Visual Studio 17.12

Se você estiver usando o VisualStudio 17.12, poderá encontrar o seguinte erro de build:

error LNK2019: unresolved external symbol __asan_wrap_wcscat referenced in function

Você pode contornar esse erro adicionando o seguinte sinalizador à linha de comando do vinculador:

/alternatename:__asan_wrap_wcscat=wcscat

Essa regressão foi corrigida no VisualStudio 17.14.15.

Regressão no VisualStudio da versão 17.14 para 17.14.14

Se você estiver usando o VisualStudio 17.14, poderá encontrar o seguinte erro de build:

error LNK2001: unresolved external symbol __LINK_WITH_asan_compat.lib_TO_USE_NEW_COMPILER_WITH_OLDER_ASAN_RUNTIME

Você pode contornar esse erro adicionando o seguinte sinalizador à linha de comando do compilador:

/fno-sanitize-address-asan-compat-lib

Adicione os seguintes sinalizadores à linha de comando do vinculador:

/alternatename:__asan_wrap_wcscat=wcscat
/alternatename:__asan_wrap_wcscpy=wcscpy
/alternatename:__asan_wrap_wcsncpy=wcsncpy

Essa regressão foi corrigida no VisualStudio 17.14.15.

Como verificar se o KASAN está habilitado no driver do kernel

Os drivers do kernel compilados com KASAN têm uma seção PE chamada "KASAN". Verifique se o KASAN está habilitado no driver executando o seguinte comando em um Prompt de Comando do Desenvolvedor:

dumpbin /ALL YourDriver.sys

Se a saída contiver uma seção chamada "KASAN", então KASAN está habilitado em seu driver.

Como analisar relatórios KASAN

Quando o KASAN detecta um acesso ilegal à memória em seu driver, ele emite a Verificação de Bugs 0x1F2: KASAN_ILLEGAL_ACCESS. Inspecione o despejo de memória do kernel gerado para determinar onde exatamente o driver executou um acesso ilegal à memória.

Use o KASAN com um depurador de kernel anexado ao sistema de destino para que a memória possa ser inspecionada dinamicamente assim que a verificação de bugs for emitida, em vez de post-mortem com um despejo de memória.

Parâmetros de verificação de bugs

Os parâmetros do Bug Check 0x1F2: KASAN_ILLEGAL_ACCESS são:

1. Parâmetro 1: Endereço que está sendo acessado ilegalmente.
2. Parâmetro 2: Tamanho do acesso à memória.
3. Parâmetro 3: Endereço do chamador que executa o acesso ilegal à memória.
4. Parâmetro 4: Informações extras sobre o acesso à memória:
   • Bits [0:7]: o código de sombra KASAN. Veja a tabela abaixo.
   • Bit 8: 1 se o acesso foi uma gravação, 0 se foi uma leitura.

Códigos de sombra KASAN

No KASAN, consideramos que toda a memória do kernel é dividida em partes contíguas de células de oito bytes alinhadas a oito bytes. Com o KASAN, cada célula de oito bytes na memória do kernel tem um código de sombra associado a ela, que é um inteiro de um byte que indica a validade da célula. A codificação dos códigos de sombra é a seguinte:

Vários subcódis são usados para as células condicionalmente válidas e totalmente inválidas para indicar ainda mais a qual tipo de memória a célula está associada e por que o acesso a ela pode ser ilegal.

Subcódis usados por células condicionalmente válidas:

• 0x09: memória paginável, que é ilegal acessar em DISPATCH_LEVEL ou superior, mas legal acessar caso contrário.

Subcódis usados por células totalmente inválidas:

• 0x81: Zona vermelha esquerda de Alloca.
• 0x82: Zona vermelha média de Alloca.
• 0x83: zona vermelha direita de alloca.
• 0x84: zona vermelha direita da variável global.
• 0x85: redzone genérico.
• 0x86: zona vermelha direita da memória do pool.
• 0x87: memória do pool liberada.
• 0x8A: zona vermelha esquerda da memória contígua.
• 0x8B: zona vermelha direita da memória contígua.
• 0x8C: memória lookasidelist liberada.
• 0x8D: redzone esquerda da memória do pool.
• 0xF1: redzone esquerda da variável de pilha.
• 0xF2: redzone médio da variável de pilha.
• 0xF3: redzone direita da variável de pilha.
• 0xF5: variável de pilha used-after-ret.
• 0xF8: variável de pilha fora do escopo.

Entenda as verificações de bugs do KASAN: um exemplo

Suponha que o KASAN emitiu uma verificação de bug quando o driver estava em execução, com estes parâmetros:

1. Parâmetro 1: 0xFFFFFFFFFFFFABCD
2. Parâmetro 2: 0x0000000000000004
3. Parâmetro 3: 0xFFFFFFFF12345678
4. Parâmetro 4: 0x0000000000000184

O parâmetro 1 informa que o driver tentou acessar o endereço 0xFFFFFFFFFFFFABCD e que esse acesso era ilegal. O parâmetro 2 informa que foi um acesso de quatro bytes. O parâmetro 3 fornece o endereço do ponteiro de instrução no qual o driver executou o acesso ilegal. O parâmetro 4 informa que esse foi um acesso de gravação e que a memória que está sendo tocada era a zona vermelha certa de uma variável global.

Em outras palavras, seu driver provavelmente tentou executar um estouro de buffer de gravação em uma variável global. Use essas informações para investigar e determinar onde e como corrigir esse bug em seu driver.

Impacto no desempenho do KASAN

O KASAN aumenta o consumo de memória do kernel e introduz uma desaceleração aproximada de duas vezes nos drivers compilados com o KASAN habilitado.

Comparação com o Verificador de Driver

O KASAN e o Verificador de Driver são recursos totalmente separados, mas são mutuamente compatíveis.

O KASAN está focado na detecção de acessos ilegais à memória e é mais eficiente do que o Verificador de Driver nesse domínio, pois usa uma abordagem mais refinada e abrange mais regiões de memória. O Verificador de Driver possui regras específicas do driver que visam encontrar outros tipos de bugs, que o KASAN não detecta. Para obter mais informações, consulte Microsoft: Introdução aos sanitizadores de kernel nas plataformas Microsoft.

Use o KASAN em conjunto com o Verificador de Driver para maximizar a detecção de bugs em seu driver.

Resources

• Microsoft: Introduzindo desinfetantes de kernel em plataformas Microsoft