API Comum Usado em Malware

Reading time: 6 minutes

Genérico

Rede

Persistência

Criptografia

Anti-Análise/VM

Stealth

Execução

Diversos

• GetAsyncKeyState() -- Registro de teclas
• SetWindowsHookEx -- Registro de teclas
• GetForeGroundWindow -- Obter nome da janela em execução (ou o site de um navegador)
• LoadLibrary() -- Importar biblioteca
• GetProcAddress() -- Importar biblioteca
• CreateToolhelp32Snapshot() -- Listar processos em execução
• GetDC() -- Captura de tela
• BitBlt() -- Captura de tela
• InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Acessar a Internet
• FindResource(), LoadResource(), LockResource() -- Acessar recursos do executável

Técnicas de Malware

Injeção de DLL

Executar uma DLL arbitrária dentro de outro processo

1. Localizar o processo para injetar a DLL maliciosa: CreateToolhelp32Snapshot, Process32First, Process32Next
2. Abrir o processo: GetModuleHandle, GetProcAddress, OpenProcess
3. Escrever o caminho para a DLL dentro do processo: VirtualAllocEx, WriteProcessMemory
4. Criar uma thread no processo que carregará a DLL maliciosa: CreateRemoteThread, LoadLibrary

Outras funções a serem usadas: NTCreateThreadEx, RtlCreateUserThread

Injeção de DLL Reflexiva

Carregar uma DLL maliciosa sem chamar as chamadas normais da API do Windows.
A DLL é mapeada dentro de um processo, resolverá os endereços de importação, corrigirá as realocações e chamará a função DllMain.

Sequestro de Thread

Encontrar uma thread de um processo e fazê-la carregar uma DLL maliciosa

1. Encontrar uma thread alvo: CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Abrir a thread: OpenThread
3. Suspender a thread: SuspendThread
4. Escrever o caminho para a DLL maliciosa dentro do processo da vítima: VirtualAllocEx, WriteProcessMemory
5. Retomar a thread carregando a biblioteca: ResumeThread

Injeção PE

Injeção de Execução Portátil: O executável será escrito na memória do processo da vítima e será executado a partir daí.

Hollowing de Processo (a.k.a RunPE)

Process Hollowing é um dos truques favoritos de evasão de defesa / execução usados por malware do Windows. A ideia é lançar um processo legítimo no estado suspenso, remover (hollow) sua imagem original da memória e copiar um PE arbitrário em seu lugar. Quando a thread primária é finalmente retomada, o ponto de entrada malicioso é executado sob a aparência de um binário confiável (frequentemente assinado pela Microsoft).

Fluxo de trabalho típico:

1. Criar um host benigno (por exemplo, RegAsm.exe, rundll32.exe, msbuild.exe) suspenso para que nenhuma instrução seja executada ainda.

STARTUPINFOA  si = { sizeof(si) };
PROCESS_INFORMATION pi;
CreateProcessA("C:\\Windows\\Microsoft.NET\\Framework32\\v4.0.30319\\RegAsm.exe",
NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);

2. Ler a carga maliciosa na memória e analisar seus cabeçalhos PE para obter SizeOfImage, seções e o novo EntryPoint.
3. NtUnmapViewOfSection / ZwUnmapViewOfSection – desmapear a base da imagem original do processo suspenso.
4. VirtualAllocEx – reservar memória RWX de SizeOfImage dentro do processo remoto.
5. WriteProcessMemory – copiar os Headers primeiro, depois iterar sobre as seções copiando seus dados brutos.
6. SetThreadContext – corrigir o valor de EAX/RAX (RCX em x64) ou Rip na estrutura de contexto para que EIP aponte para o EntryPoint da carga.
7. ResumeThread – a thread continua, executando o código fornecido pelo atacante.

Esqueleto mínimo de prova de conceito (x86):

void RunPE(LPCSTR host, LPVOID payload, DWORD payloadSize){
// 1. create suspended process
STARTUPINFOA si = {sizeof(si)}; PROCESS_INFORMATION pi;
CreateProcessA(host, NULL,NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&si,&pi);

// 2. read remote PEB to get ImageBaseAddress
CONTEXT ctx; ctx.ContextFlags = CONTEXT_FULL;
GetThreadContext(pi.hThread,&ctx);
PVOID baseAddr;
ReadProcessMemory(pi.hProcess,(PVOID)(ctx.Ebx+8),&baseAddr,4,NULL);

// 3. unmap original image & allocate new region at same base
NtUnmapViewOfSection(pi.hProcess,baseAddr);
PVOID newBase = VirtualAllocEx(pi.hProcess,baseAddr,pHdr->OptionalHeader.SizeOfImage,
MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);
// 4-5. copy headers & sections …
// 6. write new image base into PEB and set Eip
WriteProcessMemory(pi.hProcess,(PVOID)(ctx.Ebx+8),&baseAddr,4,NULL);
ctx.Eax = (DWORD)(newBase) + pHdr->OptionalHeader.AddressOfEntryPoint;
SetThreadContext(pi.hThread,&ctx);
// 7. run!
ResumeThread(pi.hThread);
}

Notas práticas observadas na campanha DarkCloud Stealer:

• O loader escolheu RegAsm.exe (parte do .NET Framework) como host – um binário assinado que provavelmente não chamará atenção.
• O stealer VB6 decifrado (holographies.exe) não é gravado no disco; ele existe apenas dentro do processo oco, dificultando a detecção estática.
• Strings sensíveis (regexes, caminhos, credenciais do Telegram) são RC4-encriptadas por string e só são decriptadas em tempo de execução, complicando ainda mais a varredura de memória.

Ideias de detecção:

• Alertar sobre processos CREATE_SUSPENDED que nunca criam janelas GUI/console antes que uma região de memória seja alocada como RWX (raro para código benigno).
• Procurar por uma sequência de chamadas NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory em diferentes processos.

Hooking

• A SSDT (System Service Descriptor Table) aponta para funções do kernel (ntoskrnl.exe) ou driver GUI (win32k.sys) para que processos de usuário possam chamar essas funções.
• Um rootkit pode modificar esses ponteiros para endereços que ele controla.
• IRP (I/O Request Packets) transmitem pedaços de dados de um componente para outro. Quase tudo no kernel usa IRPs e cada objeto de dispositivo tem sua própria tabela de funções que pode ser hookada: DKOM (Manipulação Direta de Objetos do Kernel).
• A IAT (Import Address Table) é útil para resolver dependências. É possível hookar essa tabela para sequestrar o código que será chamado.
• EAT (Export Address Table) Hooks. Esses hooks podem ser feitos a partir do userland. O objetivo é hookar funções exportadas por DLLs.
• Inline Hooks: Esse tipo é difícil de alcançar. Isso envolve modificar o código das próprias funções. Talvez colocando um salto no início delas.

Referências

• Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer