Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
RogueAssemblyHunter — Rogue Assembly Hunter è un'utility per scoprire moduli .NET CLR 'interessanti' in processi in esecuzione. | Kitploit
Strumenti/GitHubGitHub/bohops/rogueassemblyhunter
Strumenti DifensiviMemory ForensicsInformatica ForenseAnalisi MalwareRisposta agli Incidenti
GitHubbohops/rogueassemblyhunter

RogueAssemblyHunter

Rogue Assembly Hunter è un'utility per scoprire moduli .NET CLR 'interessanti' in processi in esecuzione.

Vedi Repository
1201044 anni faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

__________ _____ . .
_
____ \ ____ ____ __ __ ____ / _ \ ______ ______ ____ _ | | | .. | // _ \ / __| | _/ __ \ / /\ \ / // __// __ \ / | __ | |< | | | | ( <> ) // > | /\ / / | \ \ _ \ /| Y Y \ _\ \ |_ | || /_/_ /|/ _ > _| /____ >____ >___ >|| / /____/ | / // / / / / / / / /
___ ___ __
/ | \ __ __ / | ___________ / ~ \ | |/ \ __/ __ _ __
\ Y / | / | \ | \ /| | / _| /|
/|
| /
| _
>
|
/ / /

Rogue Assembly Hunter

Rogue Assembly Hunter è un'utilità per scoprire moduli .NET CLR 'interessanti' nei processi in esecuzione.

  • Autore: @bohops
  • Licenza: MIT
  • Progetto: https://github.com/bohops/RogueAssemblyHunter

Background

.NET è una piattaforma di sviluppo e un runtime framework molto potente e capace per la creazione e l'esecuzione di applicazioni gestite .NET. Negli ultimi anni, .NET è stato adottato dai Red Team (e simili) per strumentare tecniche di supporto alle operazioni offensive. In particolare, il passaggio da PowerShell offensivo a .NET è stato un salto logico (per molti) a causa dell'aumento della visibilità e dell'opportunità di osservazione presenti in PowerShell v5+. Di conseguenza, gli strumenti e le tecniche offensive .NET sono state utilizzate con successo per eludere le capacità difensive basate su host, bypassare i controlli delle applicazioni e per creare/preparare/distribuire/eseguire codice malevolo (simile a PowerShell).

Dal punto di vista della prevenzione, Microsoft sta facendo di più per combattere le minacce strumentate da .NET e per ridurre al minimo la superficie d'attacco complessiva di .NET. Ad esempio, Microsoft ha aggiunto funzionalità di ispezione AMSI in .NET Framework 4.8, e i meccanismi WDAC/WLDP sono piuttosto efficaci. Dal punto di vista del rilevamento/risposta, una maggiore visibilità e introspezione nell'ecosistema .NET è sempre vantaggiosa per scoprire nuovi modi per combattere le minacce incentrate su .NET.

Nel 2017, Joe Desimone (@dez_) ha scritto un articolo fantastico intitolato Hunting For In-Memory .NET Attacks. Ancora attuale oggi, l'articolo delinea i moderni vettori d'attacco .NET oltre a tecniche di rilevamento su richiesta e basate su eventi. In accompagnamento all'articolo, Joe ha rilasciato uno strumento (Get-ClrReflection) per rilevare proattivamente (e recuperare) moduli CLR .NET in memoria che non hanno un riferimento su disco. Ispirato dal lavoro di Joe e sfruttando le capacità di introspezione della libreria di diagnostica runtime CLRMD (+ le successive capacità di accesso ai dati di mscordacwks.dll), è stato creato Rogue Assembly Hunter per:

  • Ispezionare tutti i processi .NET ('gestiti') in esecuzione per moduli CLR interessanti (es. modulo/i che formano un 'assembly')
  • Ispezionare un singolo processo .NET ('gestito') (per PID) per moduli CLR interessanti
  • Osservare i processi appena avviati e tentare di ispezionarli per moduli CLR interessanti
  • Supportare diverse capacità di 'caccia' per scoprire moduli caricati in memoria, stato della firma dei moduli (se caricati da disco), moduli caricati da directory interessanti e moduli impostori (es. riferimenti a file falsi).
  • Supportare la funzionalità di esportazione dei moduli CLR (un porting rapido da Get-ClrReflection)
  • Ispirare strumenti e tecniche più interessanti

Requisiti e Dipendenze Principali

  • Eseguire in un contesto utente/processo privilegiato
  • .NET Framework 4.6.1+
  • .NET CLRMD - Libreria di introspezione Microsoft.Diagnostics.Runtime (Pacchetto NuGet)
  • ILMerge - Linker statico (Pacchetto NuGet)
  • ...e pacchetti NuGet di supporto in Visual Studio.

Note, Suggerimenti e Avvertenze

  • Eseguire come utente privilegiato con integrità elevata/sistema.
  • Le 'cacce' sono sperimentali e non garantiscono risultati completi/corretti. Attenzione ai falsi positivi (es. moduli firmati) e convalidare di conseguenza.
  • RogueAssemblyHunter utilizza CLRMD per connettersi a processi live, il che potrebbe introdurre risultati interessanti.
  • A causa della natura di scansione di RogueAssemblyHunter, esiste la possibilità di race condition e risultati mancati. Considerare la regolazione con i parametri --checks e --sleep per aiutare (specialmente in modalità 'watch'). In alcuni casi, potrebbe essere difficile 'catturare' un particolare caricamento di assembly a causa della velocità di esecuzione (come execute-assembly e processi sacrificali).
  • L'architettura ('bitness') e le versioni di .NET contano (es. 4+) per interagire con processi remoti con le librerie .NET CLRMD.
    • Per la massima ispezione/copertura, compilare ed eseguire questo programma per casi d'uso x86 e x64.
    • La modalità sweep dei processi tenterà di connettersi a tutti i processi in esecuzione indipendentemente dalla 'bitness'. Altrimenti fallirà di conseguenza per discrepanze di architettura.
  • Testato su Windows 10 Pro 2H1H e Windows Server 2016 Standard 1607. Potrebbe funzionare su altre versioni con il framework .NET pertinente.
  • Il progetto sorgente di Visual Studio con pacchetti NuGet, script PowerShell e binari di rilascio sono inclusi in questo progetto.
  • Notice.md include le liberatorie di progetto e le informazioni sulla licenza.
  • Eseguire a proprio rischio (e non badare al mio codice orribile ;) )!

Utilizzo

root@kitploit:~
[*] Parametri:
    
    --mode=<.>   : Obbligatorio | Seleziona la modalità di analisi. Opzioni: sweep, process e watch.

    --hunt=<.>   : Opzionale | Seleziona il tipo di scansione di caccia per trovare moduli CLR interessanti. Specificare all (predefinito), memory-only, unusual-dir,
                   sig-status, imposter-file o list.

    --export=<.> : Opzionale, Sperimentale | Specifica un percorso file per esportare i moduli CLR caricati per le scansioni di caccia in-memory e imposter-file 
                   (es. --hunt=memory-only/imposter-file/all).

    --pid=<.>    : Opzionale | Specifica un processo target tramite PID. Deve essere usato con il parametro/valore --mode=process.

    --checks=<.> : Opzionale | Specifica un valore per i cicli di scansione. Può aiutare a ridurre le race condition mancate durante le scansioni ma potrebbe anche ripetere l'output dei risultati.
                   Il valore predefinito è 1.

    --sleep=<.>  : Opzionale | Specifica un valore per i secondi di pausa. Può aiutare a ridurre le race condition mancate durante le scansioni ritardando il ciclo di controllo.
                   Il valore predefinito è 0 secondi.

    --debug      : Opzionale | Mostra le informazioni sulle eccezioni (es. errori di connessione al processo).

    --nobanner   : Opzionale | Sopprime il banner di visualizzazione. Utile per l'esecuzione con lo script PowerShell o per casi d'uso che sfruttano l'automazione.

    --suppress   : Opzionale | Non esegue la scansione del processo RogueAssemblyHunter durante --mode=sweep o --mode=watch.

    --help       : Opzionale | Mostra questo aiuto. Sostituirà qualsiasi altro parametro della riga di comando e uscirà dall'applicazione. *Questo è il comportamento predefinito senza parametri.


[*] Modalità (--mode=)

    - sweep   : Scansiona/itera attraverso tutti i processi (Nota: Solo i processi della stessa architettura/'bitness' verranno scansionati con successo. Compilare per eseguire per x86/x64/ecc.).

    - process : Scansiona un singolo processo. Usare con --pid=<PID>.
    
    - watch   : Scansiona i nuovi processi quando vengono creati. Regola gli attributi di scansione con --checks e --sleep. (Nota: Questo è sperimentale. Le race condition sono probabili.)


[*] Cacce (--hunt=)

    - all           : Valore predefinito. Analizza con tutte le opzioni di caccia (eccetto 'list').

    - memory-only   : Caccia in memoria. Analizza i moduli CLR che non sono supportati dal disco.

    - unusual-dir   : Caccia in directory insolite. Analizza i moduli CLR caricati al di fuori delle directory 'normali'.
                      Modificare '_huntUnusualDirectoryFilter' per personalizzare.

    - sig-status    : Caccia alla firma del file. Analizza i moduli CLR con stato di firma anomalo (es. non firmati). Nota: Questo è sperimentale. Sono possibili falsi positivi.
                      Modificare '_huntSigExclusionsFilter' per personalizzare.
    
    - imposter-file : Caccia ai moduli CLR inaspettati. Analizza il modulo CLR con supporto di file su disco sospetto. Sperimentale.
    
    - list          : Itera attraverso tutti i moduli CLR e li elenca di conseguenza.


[*] Esempi di Utilizzo
    
    - Esempio 1 : Scansiona i processi ed esegue tutte le cacce per i processi 64-bit accessibili (eccetto 'list') -
                  RogueAssemblyHunter_x64.exe --mode=sweep
    
    - Esempio 2 : Scansiona i processi, elenca tutti i moduli CLR nei processi gestiti 32-bit accessibili e mostra le informazioni sugli errori -
                  RogueAssemblyHunter_x86.exe --mode=sweep --hunt=list --debug

    - Esempio 3 : Osserva i nuovi processi, scansiona tutti i moduli CLR (se gestiti e 64-bit), non esegue la scansione del processo RogueAssemblyHunter e fa 2 controlli con un ritardo di 3 secondi -
                  RogueAssemblyHunter_x64.exe --mode=watch --suppress --checks=2 --sleep=3

    - Esempio 4 : Scansiona un singolo processo per PID, elenca i risultati dei moduli CLR solo in memoria ed esporta i moduli CLR nel percorso specificato -
                  RogueAssemblyHunter_x86.exe --mode=process --pid=4650 --hunt=memory-only --export=c:\evilassemblies\
    
    - Esempio 5 : Scansiona i processi, elenca i risultati dei moduli CLR solo in memoria per i processi 64-bit accessibili, non esegue la scansione del processo RogueAssemblyHunter e non mostra il banner del titolo -
                  RogueAssemblyHunter_x64.exe --mode=sweep --hunt=memory-only --suppress --nobanner

File di Rilascio: Invoke-RogueAssemblyHunter & Binari Compilati

Per comodità, uno script PowerShell insieme a due binari compilati (RogueAssemblyHunter_x64.exe e RogueAssemblyHunter_x86.exe) sono stati inclusi nella cartella \Release. Sentiti libero di modificare per adattarli ai tuoi casi d'uso (es. distribuzione, incorporamento, controlli, sleep, ecc.).

Esempio di Utilizzo:

Esegui Invoke-RogueAssemblyHunter in modalità sweep e controlla tutte le opzioni di caccia

root@kitploit:~
cd c:\path\to\RogueAssemblyHunter
import-module .\Invoke-RogueAssemblyHunter.ps1
Invoke-RogueAssemblyHunter

Esegui Invoke-RogueAssemblyHunter in modalità watch e controlla tutte le opzioni di caccia

root@kitploit:~
cd c:\path\to\RogueAssemblyHunter
import-module .\Invoke-RogueAssemblyHunter.ps1
Invoke-RogueAssemblyHunter -ScanMode watch

SHA256 Hashes:

root@kitploit:~
e804711a8b6469f1b13b388de47dfa6dde1c85279d365db7b6e19e1644990fa6  Invoke-RogueAssemblyHunter.ps1
cc985d918e566671aa209142abc55bd798ca6c1a18730b785ac8c18d489736c3  RogueAssemblyHunter_x64.exe
ae3aead43871e263cd8465d5356c4daaae0635714321f872c931ec825008287a  RogueAssemblyHunter_x86.exe

Roadmap

  • Analisi dei file di dump gestiti (.dmp)
  • Miglioramento dei controlli sullo stato della firma
  • Miglioramenti dell'output (es. json)
  • Stabilità e correzioni di bug

Crediti, Ispirazione e Risorse

  • Hunting For In-Memory .NET Attacks | di Joe Desimone (@dez_)
  • Get-ClrReflection | di Joe Desimone (@dez_)
  • Get-InjectedThread | di Jared Atkinson (@jaredcatkinson)
  • pe-sieve | di hasherezade (@hasherezade)
  • CLR MD — Analyzing Live Process | di Harsha
  • How to enumerate Modules in each App Domain using ClrMD | di Sukesh Ashok Kumar
  • WMIProcessWatcher | di Tim MalcomVetter (@malcomvetter)
Scarica lo strumento