Como arruinei minhas férias com engenharia reversa do WSC

• Compartilhamento da experiência no desenvolvimento do defendnot, uma ferramenta que desativa o Windows Defender usando diretamente a API de serviço do Windows Security Center (WSC)
• O projeto começou no processo de superar as limitações técnicas e os problemas legais do projeto anterior, o no-defender
• A engenharia reversa e a depuração foram feitas em meio a vários obstáculos, como ambiente especial (MacBook arm64, depuração remota, alta latência)
• Analisou o desvio do registro no Defender e o mecanismo de verificação de processos, melhorando o funcionamento até ficar estável após várias falhas e tentativas
• No fim, implementou até a função de execução automática, ao mesmo tempo em que relembra o quanto o processo foi difícil

---

Introdução

• Relato da jornada de implementação da ferramenta defendnot, que desativa o Windows Defender
• Em vez de focar nos principais detalhes técnicos, o texto é organizado em torno dos problemas enfrentados no ambiente real e das tentativas frustradas
• A documentação formal e a explicação técnica detalhada serão publicadas separadamente depois

Relembrando 1 ano atrás

• Cerca de 1 ano atrás, foi publicado um projeto chamado no-defender, que explorava a forma como o Windows Defender é desativado via API do WSC
• Esse projeto fingia que outro antivírus estava registrado no sistema ao referenciar código de terceiros de um fornecedor de antivírus
• Após o lançamento, recebeu grande atenção e cerca de 1.500 stars, mas decidiu remover o código-fonte e encerrar o projeto por causa de um pedido de remoção por DMCA da empresa de antivírus relacionada

Como o projeto começou

• No momento da escrita, o autor estava hospedado em um Airbnb em Seul
• O principal ambiente de desenvolvimento era um MacBook M4Pro, e ele não levou um dispositivo separado para engenharia reversa em x86, que era essencial
• Por causa de um CTF e da agenda de viagem, surgiu a situação de precisar trabalhar sem um dispositivo x86
• Junto com a análise da possibilidade de uma implementação “correta” do projeto no-defender, começou a explorar se seria possível uma implementação independente, sem depender de AV

Investigação inicial (Dia 1)

• Com a ajuda de um amigo, conseguiu o binário do WSC e tentou reimplementar o registro no WSC com uma estrutura parecida com a do projeto anterior
• Implementou usando a API COM do WSC, mas recebeu um erro de Access Denied
• Identificou a causa no processo de verificação de assinatura e autenticação do processo que chama a API pelo WSC
• Quando tentou registrar injetando um módulo em um processo de AV, o registro do antivírus foi concluído com sucesso

Substituição do binário de AV e experimentos adicionais (Dia 1)

• Tentou executar a ferramenta por meio de processos de sistema assinados, como cmd.exe, mas falhou na verificação de PPL (Protected Process Light)
• Interrompeu temporariamente o trabalho, prometendo fazer uma desmontagem e rastreamento detalhados para análise

Montagem do ambiente (Dia 2)

• Devido às limitações do ambiente MacBook arm64, depurar Windows x86 era muito difícil
• Usou remotamente o PC de um amigo que mora nos EUA, com Parasec, Anydesk etc., para fazer depuração e testes em ambiente de alta latência
• No processo em que a compilação do código e a depuração da VM se cruzavam de forma complexa, enfrentou lentidão e confusão

Depuração do serviço WSC (Dia 2)

• Confirmou que o serviço WSC tem a estrutura de uma DLL executada pelo svchost
• Aplicou um desvio com um driver especial para remover a proteção PPL e confirmou com o depurador a entrada na função
• Identificou que dentro do serviço estava sendo feita a verificação do token SID do WinDefend
• Formulou a teoria de que seria possível contornar o processo de autenticação imitando um processo com o SID do WinDefend

Imitação do SID do WinDefend (Dia 2)

• Fez estudo adicional sobre a estrutura dos tokens do Windows e seu funcionamento
• Depois de implementar e executar o código de imitação do SID do WinDefend, verificou que todas as chamadas COM retornavam SUCCESS, mas o AV na prática não era registrado

Reconstrução do algoritmo de verificação (Dia 3)

• Reanalisou cuidadosamente no binário do AV se a checagem de SID realmente estava sendo aprovada
• Quando a checagem de SID falhava, o serviço também verificava estado elevado de privilégio, assinatura do binário e o flag DllCharacteristics (ForceIntegrity) do PE
• Reproduziu a função que executava essa estrutura e fez testes aplicando-a a binários centrais do sistema

Uso do processo Taskmgr (Dia 3)

• Tentou novamente usando o Taskmgr.exe como processo-alvo, mas enfrentou o problema de o WSC rejeitar a solicitação devido a erro no processo de transmissão do nome e bug de IPC
• Depois de melhorar a inferência do caminho do arquivo e a forma de transmitir o nome do AV, confirmou o funcionamento normal

Organização do código (Dia 3)

• Organizou as funcionalidades e tentou implementar a função de execução automática (autorun)
• Sofreu falhas intermitentes no gerenciamento da execução automática e repetiu várias vezes a inspeção do código e do ambiente para descobrir a causa

Implementação da execução automática (Dia 4)

• Confirmou que a causa era uma opção do Task Scheduler: a caixa que impede a execução da tarefa quando o notebook não está conectado à energia AC estava marcada
• Depois de desativar essa configuração, a execução automática passou a funcionar normalmente
• Para finalizar, fez limpeza de código e testes

Conclusão

• O trabalho de engenharia reversa em um ambiente limitado e desconfortável foi uma experiência psicologicamente e fisicamente muito difícil
• Uma documentação mais detalhada sobre a implementação do WSC será publicada separadamente no futuro

Agradecimentos

• Pindos: amigo que cedeu o PC à noite para ajudar na depuração e ainda aqueceu o quarto
• MrBruh: colega que deu o impulso inicial para começar a explorar o projeto e ofereceu feedback sobre as ideias
• Pessoas próximas que mantiveram contato durante o projeto e deram apoio
• Confessa seu amor por kimchi
• Também agradece ao artista que deixou grafite na nossa parede

[GN⁺]

Comentários do Hacker News

• A forma mais forte, porém mais invasiva, de desativar o Defender é inicializar por um Live Linux USB, renomear a pasta C:\ProgramData\Microsoft\Windows Defender e então criar um arquivo vazio no lugar
  • A Política de Grupo funciona tão bem que montei um ambiente de domínio local no homelab com um controlador para alterar automaticamente as políticas do Defender para todos os usuários
  • É estranho que o Windows não tenha um manifesto assinado para detectar esse tipo de adulteração
  • Produtos populares na prática também fazem isso, e já derrubaram cerca de 25% de toda a internet
• O projeto gerou bastante repercussão e recebeu cerca de 1,5 mil estrelas, mas depois o desenvolvedor do antivírus que eu usava enviou uma notificação DMCA. Não entendo qual é o “antivírus que eu usava” nem por que essa pessoa enviaria um DMCA. Provavelmente o autor fez engenharia reversa de outro antivírus e colocou isso em código aberto, ou pelo menos tem relação com imitar o WinDefend. Parece ter havido um problema de direitos autorais
  • Pelo que entendi, parece que ele usou a carcaça de outra ferramenta de antivírus para contornar os requisitos de assinatura. É transformativo, então talvez seja defensável (não sou especialista jurídico), mas é uma área cinzenta
  • Sim, ele copiou partes de um antivírus existente e violou a lei de direitos autorais. O parágrafo logo acima do trecho citado também explica que o projeto usou código de terceiros de um antivírus existente para registrar o AV no WSC
• Para referência, WSC significa Windows Security Center
  • Obrigado pela ajuda. Fico realmente frustrado quando uma sigla aparece pela primeira vez sem explicação
• Isto é realmente bizarro: https://github.com/es3n1n/defendnot/… Se tiver curiosidade sobre o que de fato acontece, veja aqui: https://github.com/es3n1n/defendnot/…
  • Gostaria que alguém capaz de explicar bem magia de CPP pudesse explicar por que esse código é bizarro
  • Não vejo o que há de estranho nisso. Eu uso bem esse padrão em várias partes do código. A assinatura no ponto de chamada é diferente, mas isso é preferência pessoal. Aliás, a linguagem D tem sintaxe embutida para disparar algo no fim do escopo
  • Por falta de tempo, fiquei com preguiça de implementar manualmente o padrão RAII para todos os componentes COM. Vou trocar isso na próxima atualização
  • “Código é como você trata seus colegas” - Michael Feather Em resumo, não é IA O código serve para adiar a chamada de uma função quando o escopo de um objeto termina. Ele usa macros em C para simplificar definições complexas de lambdas/funções anônimas em C e a geração de nomes de variáveis únicos. Só que, como as macros não estão em maiúsculas e parecem chamadas de função, quem não está acostumado pode se confundir. Para algumas pessoas, esse padrão é útil o bastante para ser considerado idiomático. A explicação técnica pode ser vista no link de outro comentário
• No ano passado, aproveitei muito as férias fazendo engenharia reversa dos desktops virtuais do Windows; foi uma ótima lembrança. Engenharia reversa é realmente divertida. Aprendi várias coisas interessantes, por exemplo que existe uma forma não documentada de troca de mensagens dentro do Windows RPC: https://csandker.io/2022/05/24/Offensive-Windows-IPC-3-ALPC.html
• Li recentemente https://nostarch.com/windows-security-internals, e isso tornou o artigo ainda mais fácil de me identificar. Eu já entendia em certa medida como o backend funciona no Windows, mas o último capítulo desse livro explica tokens e SIDs com tanto detalhe quanto o autor aborda
• Fico curioso sobre por que alguém iria querer desativar o WSC
  • Pode ser por desempenho, desenvolvimento de malware, hacking e coisas do tipo
  • Se for um agente de ameaça, ele pode ter a sorte de não haver outro produto de EDR instalado. Mas, se houver, quase certamente será bloqueado. Se for um fornecedor de EDR, isso pode ser usado como uma chamada de API ofuscada para desativar o firewall do Windows. Produtos como o CrowdStrike também podem usar seu próprio firewall ou substituir o firewall do Windows
  • Todo software antivírus é, no mínimo, um powervirus. Não gosto da ideia de alguém me policiando por eu usar netcat.exe
  • O hardware é meu, então vou usá-lo do jeito que eu quiser. É um motivo simples
  • Fico me perguntando por que alguém iria querer instalar um rootkit no próprio sistema
• O pior, para mim, é que o Check Point Harmony não usa de forma alguma a interface criada para o Defender e, em vez disso, orienta os usuários em um artigo da base de conhecimento a desativar o Defender diretamente
• Caso alguém esteja curioso: WSC significa Windows Security Center. Eu também precisei procurar
  • A frase “Quem gerencia tudo isso é o Windows Security Center-WSC” está incluída no artigo
• Sobre o trecho “estou trabalhando em um macbook arm64 e atualmente não existe uma forma decente de emular Windows x86 em um arm macbook”, perguntaram sobre o UTM e mencionaram que o Parallels começou recentemente a oferecer suporte a VMs Intel
  • Já usei o UTM, mas com Windows x86 era inutilizável. Talvez Linux em linha de comando fique em uma velocidade aceitável, mas em ambiente GUI é impossível. O Windows arm64 roda bem, mas como isso não é Windows x86, não serve para fazer engenharia reversa de componentes de sistema x86
  • O sistema de recompilação dinâmica do QEMU não é tão eficiente quanto os sistemas nativos do Windows ou do macOS (Rosetta 2). O Windows x86 até roda no UTM, mas o desempenho é muito ruim. Na prática, sinto que é melhor executar apps x86 em uma VM de Windows ARM com o recompilador dinâmico do próprio Windows, ou usar o WINE, que depende de subsistemas baseados em código nativo. Para uma necessidade rápida e simples, talvez sirva. Se o “decente” que o autor menciona inclui desempenho, entendo a posição
  • Posso estar enganado, então me corrijam se for o caso, mas parece correto dizer que emular uma CPU com MMU é inerentemente lento e difícil de otimizar. Tecnologias como o Rosetta da Apple e a equivalente da Microsoft são rápidas porque executam apenas código em espaço de usuário. Elas evitam a emulação completa do MMU do sistema