Shhhloader

Shhhloader é um carregador de shellcode em desenvolvimento. Ele recebe shellcode bruto como entrada e compila um stub em C++ que realiza várias ações para tentar contornar AV/EDR. O construtor Python incluído funciona em qualquer sistema Linux com Mingw-w64 instalado.

Edição de 25/01/24: Shhhloader agora suporta a variante 7 do PoolParty! Foi adicionada também uma opção que combina PoolParty com Module Stomping para evitar que o shellcode executado resida em memória não backed. Veja abaixo um vídeo demonstrando este novo método de injeção contra o Defender ATP:

┳┻|
┻┳|
┳┻|
┻┳|
┳┻| _
┻┳| •.•)  - Shhhhh, AV pode nos ouvir! 
┳┻|⊂ﾉ   
┻┳|
usage: Shhhloader.py [-h] [-p explorer.exe] [-m QueueUserAPC] [-u] [-w] [-nr] [-ns] [-l] [-v] [-sc GetSyscallStub] [-d] [-dp apphelp.dll] [-s domain]
                     [-sa testlab.local] [-o a.exe] [-pp explorer.exe] [-ppv] [-np] [-cp] [-td ntdll.dll] [-ef NtClose]
                     file

CARREGADOR DE SHELLCODE COM SYSCALL PERSONALIZADO DO ICYGUIDER

positional arguments:
  file                  Arquivo contendo shellcode bruto

options:
  -h, --help            mostra esta mensagem de ajuda e sai
  -p explorer.exe, --process explorer.exe
                        Processo para injetar (Padrão: explorer.exe)
  -m QueueUserAPC, --method QueueUserAPC
                        Método para execução do shellcode (Opções: PoolPartyModuleStomping, PoolParty, ThreadlessInject, ModuleStomping, QueueUserAPC,
                        ProcessHollow, EnumDisplayMonitors, RemoteThreadContext, RemoteThreadSuspended, CurrentThread) (Padrão: QueueUserAPC)
  -u, --unhook          Desenganchar NTDLL no processo atual
  -w, --word-encode     Salvar shellcode no stub como um array de palavras em inglês
  -nr, --no-randomize   Desabilitar aleatorização de nomes de syscall
  -ns, --no-sandbox     Desabilitar verificações de sandbox
  -l, --llvm-obfuscator
                        Usar Obfuscator-LLVM para compilar o stub
  -v, --verbose         Habilitar mensagens de depuração durante a execução
  -sc GetSyscallStub, --syscall GetSyscallStub
                        Método de execução de syscall (Opções: SysWhispers2, SysWhispers3, GetSyscallStub, None) (Padrão: GetSyscallStub)
  -d, --dll             Gerar uma DLL em vez de EXE
  -dp apphelp.dll, --dll-proxy apphelp.dll
                        Criar DLL Proxy usando uma DLL legítima fornecida (O arquivo deve existir no diretório atual)
  -s domain, --sandbox domain
                        Técnica de evasão de sandbox (Opções: sleep, domain, hostname, username, dll) (Padrão: sleep)
  -sa testlab.local, --sandbox-arg testlab.local
                        Argumento para técnica de evasão de sandbox (Ex: WIN10CO-DESKTOP, testlab.local)
  -o a.exe, --outfile a.exe
                        Nome do arquivo compilado

PPID Spoofing:
  -pp explorer.exe, --ppid explorer.exe
                        Processo pai a ser usado para PPID Spoofing (Padrão: explorer.exe)
  -ppv, --ppid-priv     Habilitar falsificação para processo pai privilegiado (Desabilitado por padrão)
  -np, --no-ppid-spoof  Desabilitar falsificação de PPID

ThreadlessInject:
  -cp, --create-process
                        Criar processo em vez de injetar em um existente
  -td ntdll.dll, --target-dll ntdll.dll
                        DLL alvo contendo função de exportação a ser sobrescrita
  -ef NtClose, --export-function NtClose
                        Função de exportação a ser sobrescrita

Funcionalidades:

• 10 Métodos Diferentes de Execução de Shellcode (PoolParty, PoolPartyModuleStomping, ThreadlessInject, ModuleStomping, QueueUserAPC, ProcessHollow, EnumDisplayMonitors, RemoteThreadContext, RemoteThreadSuspended, CurrentThread)
• Falsificação de PPID
• Bloquear DLLs de Terceiros
• Desenganchar NTDLL via KnownDLLs
• SysWhispers2, SysWhispers3 e GetSyscallStub
• Hashing de API para SW2 e SW3
• Criptografia de Strings em Tempo de Compilação
• Suporte a Obfuscator-LLVM (OLLVM)
• Geração Automática de DLL Proxy
• Integração com Havoc C2 Framework
• Aleatorização de Nomes de Syscall
• Armazenar Shellcode como Array de Palavras em Inglês
• Codificação XOR com Geração Dinâmica de Chave
• Evasão de Sandbox via DLL Carregada, Domínio, Usuário, Nome de Máquina e Enumeração do Sistema

Veja abaixo um vídeo PoC do método ThreadlessInject sendo usado para injetar um beacon Havoc no IE sem gerar alertas e com eventos mínimos no Microsoft Defender for Endpoint (MDE) EDR (Gravado em 03/04/2023):

Veja o vídeo abaixo demonstrando a técnica de injeção Module Stomping executada via DLL Proxying (Gravado em 09/08/2022):

O Shhhloader também foi integrado ao Havoc C2 Framework através de um módulo criado por @jakobfriedl. Veja abaixo um vídeo demonstrando o módulo:

Problemas Conhecidos/Notas:

• Os métodos de injeção PoolParty estão configurados atualmente para injetar em um processo existente. Portanto, você deve usar a flag -p para fornecer o nome de um processo que você sabe ou suspeita estar em execução no sistema alvo.
• Os métodos de injeção PoolParty não funcionarão com arquivos de shellcode grandes, como o sliver (~11MB).
• O método de execução de shellcode ThreadlessInject deve atualmente injetar em um processo não suspenso. Isso é feito automaticamente para você se a opção "-cp" for fornecida. Espero descobrir uma maneira de fazê-lo funcionar com processos suspensos em breve.
• O módulo Havoc C2 atualmente trava ao especificar um Listener em vez de um arquivo de shellcode bruto. Isso será corrigido em breve, espero.
• O Windows Defender detectará a maioria dos arquivos gerados por esta ferramenta, então, por favor, não abra uma issue dizendo "DETECTADO!!!". Brinque com as novas opções e funcionalidades até conseguir algo que funcione; elas foram adicionadas por um motivo :). Executar o arquivo gerado em memória também é uma boa maneira de evitar essas detecções.
• O Obfuscator-LLVM (OLLVM) não é compatível com SW2 e SW3 devido à forma como o clang lida com assembly inline. Não há planos atuais para torná-los compatíveis; foram adicionadas verificações para impedir que o usuário tente usar esses recursos juntos.
• Existem muitos bugs no meu código. Por favor, teste tudo com antecedência antes de usar para algo importante, e FORNEÇA o máximo de informações possível ao abrir uma issue. (OBRIGADO!)

Atualizações Planejadas:

• Opção de syscall via Hardware Breakpoint (HWBP)
• Criar processos usando syscall em vez de função WinAPI padrão
• Integrar ThreadlessInject com outras técnicas de injeção de shellcode (Ex. ModuleStomping)
• Refatorar código para ser mais modular e legível
• Corrigir bugs no módulo Havoc C2
• Corrigir inúmeros bugs aprendendo a programar melhor ;)

OPCIONAL: Para usar a flag Obfuscator-LLVM, você precisa tê-lo instalado no seu sistema junto com wclang. Achei isso um pouco trabalhoso, mas você deve conseguir com um pouco de perseverança. Aqui está um passo a passo que usei para instalar o branch llvm-13.x do OLLVM no meu sistema Kali Linux:

# Clone e Execute CMake
git clone -b llvm-13.x https://github.com/heroims/obfuscator.git
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_NEW_PASS_MANAGER=OFF ../obfuscator/llvm/

# Configure CMake e Compile o OLLVM
export clang_build_dir=$(cd ../; pwd)/obfuscator/clang
sed -i 's/LLVM_TOOL_CLANG_BUILD:BOOL=OFF/LLVM_TOOL_CLANG_BUILD:BOOL=ON/g' CMakeCache.txt
sed -i "s|LLVM_EXTERNAL_CLANG_SOURCE_DIR:PATH=|LLVM_EXTERNAL_CLANG_SOURCE_DIR:PATH=$clang_build_dir|g" CMakeCache.txt
make -j7

# APÓS COMPILAR, FAÇA BACKUP DOS BINÁRIOS ORIGINAIS DO CLANG
mv /usr/bin/clang /usr/bin/clang13.0.1
mv /usr/bin/clang++ /usr/bin/clang++13.0.1

# Então, no diretório OLLVM build/bin, copie os novos bins do clang
cp bin/clang /usr/bin/clang
cp bin/clang++ /usr/bin/clang++

# Depois instale o wclang
cd ..
git clone https://github.com/tpoechtrager/wclang.git
cd wclang/
cmake -DCMAKE_INSTALL_PREFIX=_prefix_ .
make
make install
export wclang_path=$(pwd)/_prefix_/bin
echo "export PATH=$wclang_path:$PATH" >> ~/.bashrc
export PATH=$wclang_path:$PATH

# Então faça backup dos arquivos lib originais
cp -R /lib/llvm-13/lib/clang/13.0.1/include/ /lib/llvm-13/lib/clang/13.0.1/include_backup/

# Finalmente, no diretório OLLVM build/bin/lib/clang/13.0.1/, copie a pasta include
cd ../build/lib/clang/13.0.1/
cp -R include/ /lib/llvm-13/lib/clang/13.0.1/

Provavelmente existe uma maneira melhor de fazer isso, mas foi o que funcionou para mim. Se tiver problemas, continue tentando e certifique-se de que você consegue executar x86_64-w64-mingw32-clang++ -v e que ele contém "Obfuscator-LLVM" ou "heroims" na saída. Infelizmente não tenho tempo para ajudar indivíduos que precisam de mais ajuda, mas você pode tentar ler esta issue no meu repositório Nimcrypt2, onde alguns usuários descobriram como fazer isso em seus sistemas.

Saudações e Créditos:

• @Jackson_T por seu incrível projeto SysWhispers: https://github.com/jthuraisamy/SysWhispers
• @FalconForceTeam por sua ferramenta de geração de syscall que suporta SysWhispers2: https://github.com/FalconForceTeam/SysWhispers2BOF
• @snovvcrash por seu projeto DInjector, que usei como modelo para muitas das técnicas de injeção incluídas: https://github.com/snovvcrash/DInjector
• @Cerbersec por seu projeto Ares, cujo código usei para PPID Spoofing, Bloqueio de DLLs de Terceiros e Evasão de Sandbox: https://github.com/Cerbersec/Ares
• @spotheplanet por seu post no blog sobre Recuperação de Stubs Syscall do ntdll a partir do Disco em Tempo de Execução: https://www.ired.team/offensive-security/defense-evasion/retrieving-ntdll-syscall-stubs-at-run-time
• @_RastaMouse por seu código e artigo sobre Module Stomping, que portei para C++: https://offensivedefence.co.uk/posts/module-stomping/
• @s4ntiago_p por seu projeto NanoDump e especialmente pelo script randomize_sw2_seed.py: https://github.com/helpsystems/nanodump
• @skadro-official por seu projeto skCrypter, que esta ferramenta utiliza para criptografia de strings em tempo de compilação: https://github.com/skadro-official/skCrypter
• @_EthicalChaos_ por seu projeto ThreadlessInject: