Modular framework for discovering and analyzing open directories on the web. Crawls URLs, extracts content, applies YARA/ClamAV scanning, and outputs results to MISP, SQLite, or console for threat intelligence. Translation: Framework modulare per scoprire e analizzare directory aperte sul web. Scansiona URL, estrae contenuti, applica scansione YARA/ClamAV e produce risultati in MISP, SQLite o console per l'intelligence sulle minacce.
SubCrawl è un framework sviluppato da Patrick Schläpfer, Josh Stroschein e Alex Holland del team Threat Research di HP Inc. SubCrawl è progettato per trovare, scansionare e analizzare directory aperte. Il framework è modulare, composto da quattro componenti: moduli di input, moduli di elaborazione, moduli di output e il motore di crawling principale. Gli URL sono i valori di input primari, che il framework analizza e aggiunge a un sistema di coda prima di eseguirne il crawling. L'analisi degli URL è un primo passo importante, poiché prende un URL inviato e genera URL aggiuntivi da scansionare rimuovendo le sottodirectory, una alla volta, finché non ne rimangono. Questo processo garantisce un tentativo di scansione più completo di un server web e può portare alla scoperta di contenuti aggiuntivi. In particolare, SubCrawl non utilizza un metodo di forza bruta per la scoperta degli URL. Tutti i contenuti scansionati provengono dagli URL di input, dal processo di analisi dell'URL e dalla scoperta durante il crawling. Quando viene scoperta una directory aperta, il motore di crawling estrae i collegamenti dalla directory per la valutazione. Il motore di crawling determina se il collegamento è un'altra directory o un file. Le directory vengono aggiunte alla coda di crawling, mentre i file vengono sottoposti a ulteriori analisi da parte dei moduli di elaborazione. I risultati vengono generati e memorizzati per ogni URL scansionato, come gli hash SHA256 e fuzzy del contenuto, se è stata trovata una directory aperta, o le corrispondenze con le regole YARA. Infine, i dati dei risultati vengono elaborati secondo uno o più moduli di output, di cui attualmente ce ne sono tre. Il primo fornisce l'integrazione con MISP, il secondo stampa semplicemente i dati sulla console e il terzo memorizza i dati in un database SQLite. Poiché il framework è modulare, non solo è facile configurare quali moduli di input, elaborazione e output si desiderano, ma è anche semplice sviluppare nuovi moduli.
Figura 1 - Architettura di SubCrawl
SubCrawl supporta due diverse modalità operative. In primo luogo, SubCrawl può essere avviato in modalità run-once. In questa modalità, l'utente fornisce gli URL da scansionare in un file in cui ogni valore di input è separato da un'interruzione di riga. La seconda modalità operativa è la modalità servizio. In questa modalità, SubCrawl viene eseguito in background e si basa sui moduli di input per fornire gli URL da scansionare. La Figura 1 mostra una panoramica dell'architettura di SubCrawl. I componenti utilizzati in entrambe le modalità operative sono blu, i componenti della modalità run-once sono gialli e i componenti della modalità servizio sono verdi.
In base alla modalità di esecuzione scelta, devono essere soddisfatti altri prerequisiti.
SubCrawl è scritto in Python3. Inoltre, ci sono diversi pacchetti necessari prima di eseguire SubCrawl. Il seguente comando può essere utilizzato per installare tutti i pacchetti richiesti prima di eseguire SubCrawl. Dalla directory crawler, esegui il seguente comando:
$ sudo apt install build-essential
$ pip3 install -r requirements.txt
Se SubCrawl viene avviato in modalità servizio, è possibile farlo utilizzando Docker. Per questo motivo, è richiesta l'installazione di Docker e Docker Compose. Buone istruzioni di installazione per questo si trovano direttamente sul sito web Docker.com.
SubCrawl dispone di un aiuto integrato tramite l'argomento -h/--help o semplicemente eseguendo lo script senza alcun argomento.
******** ** ****** **
**////// /** **////** /**
/** ** **/** ** // ****** ****** *** ** /**
/*********/** /**/****** /** //**//* //////** //** * /** /**
////////**/** /**/**///**/** /** / ******* /** ***/** /**
/**/** /**/** /**//** ** /** **////** /****/**** /**
******** //******/****** //****** /*** //******** ***/ ///** ***
//////// ////// ///// ////// /// //////// /// /// ///
~~ Harvesting the Open Web ~~
usage: subcrawl.py [-h] [-f FILE_PATH] [-k] [-p PROCESSING_MODULES] [-s STORAGE_MODULES]
optional arguments:
-h, --help show this help message and exit
-f FILE_PATH, --file FILE_PATH
Path of input URL file
-k, --kafka Use Kafka Queue as input
-p PROCESSING_MODULES, --processing PROCESSING_MODULES
Processing modules to be executed comma separated.
-s STORAGE_MODULES, --storage STORAGE_MODULES
Storage modules to be executed comma separated.
Available processing modules:
- ClamAVProcessing
- JARMProcessing
- PayloadProcessing
- TLSHProcessing
- YARAProcessing
Available storage modules:
- ConsoleStorage
- MISPStorage
- SqliteStorage
Questa modalità è adatta se si desidera scansionare rapidamente una quantità gestibile di domini. A tal fine, gli URL da scansionare devono essere salvati in un file, che funge quindi da input per il crawler. Di seguito è riportato un esempio di esecuzione in modalità run-once, nota che l'argomento -f viene utilizzato con un percorso a un file.
python3 subcrawl.py -f urls.txt -p YARAProcessing,PayloadProcessing -s ConsoleStorage
Con la modalità servizio è possibile scansionare una quantità maggiore di domini e salvare i risultati. In base al modulo di archiviazione selezionato, i dati possono quindi essere analizzati e valutati in modo più dettagliato. Per rendere l'esecuzione della modalità servizio il più semplice possibile per l'utente, abbiamo integrato tutte le funzionalità in un'immagine Docker. In modalità servizio, i domini da scansionare vengono ottenuti tramite i moduli di input. Per impostazione predefinita, nuovi URL di malware e phishing vengono scaricati da URLhaus e PhishTank e messi in coda per la scansione. I moduli di elaborazione e archiviazione desiderati possono essere inseriti direttamente nel config.yml. Per impostazione predefinita, sono attivati i seguenti moduli di elaborazione, che utilizzano l'archiviazione SQLite:
Oltre al modulo di archiviazione SQLite, è stata sviluppata una semplice interfaccia web che consente di visualizzare e gestire i domini e gli URL scansionati.
Tuttavia, se questa interfaccia non è sufficiente per la successiva valutazione dei dati, il modulo di archiviazione MISP può essere attivato in alternativa o in aggiunta. Le impostazioni corrispondenti devono essere effettuate in config.yml nella sezione MISP.
I due comandi seguenti sono sufficienti per clonare il repository GIT, creare il contenitore Docker e avviarlo direttamente. Successivamente, l'interfaccia web è raggiungibile all'indirizzo https://localhost:8000/. Tieni presente che una volta avviati i contenitori, i moduli di input inizieranno ad aggiungere URL alla coda di elaborazione e il motore inizierà a eseguire il crawling degli host.
git clone https://github.com/hpthreatresearch/subcrawl.git
docker-compose up --build
I moduli di input vengono utilizzati solo in modalità servizio. Se SubCrawl viene avviato in modalità run-once, è necessario fornire un file contenente gli URL da scansionare. I seguenti due moduli di input sono stati implementati.
URLhaus è un importante servizio web che tiene traccia degli URL dannosi. Il servizio web fornisce anche esportazioni contenenti nuovi URL rilevati. Questi URL di malware servono come input perfetto per il nostro crawler, poiché vogliamo principalmente analizzare domini dannosi. Vengono recuperati gli URL recentemente inviati e i risultati della ricerca non vengono raffinati tramite la richiesta API (ad esempio tramite tag o altri parametri disponibili). La richiesta HTTP effettuata in questo modulo di input all'API di URLHaus può essere modificata per raffinare ulteriormente i risultati ottenuti.
PhishTank è un sito web che raccoglie URL di phishing. Gli utenti hanno la possibilità di inviare nuove pagine di phishing trovate. Un'esportazione con URL di phishing attivi può essere generata e scaricata da questo servizio web tramite API. Quindi anche questa è una raccolta ideale per il nostro crawler.
SubCrawl include diversi moduli di elaborazione. I moduli di elaborazione seguono tutti un comportamento simile su come restituiscono i risultati al motore principale. Se vengono trovate corrispondenze, i risultati vengono restituiti al motore principale e successivamente forniti ai moduli di archiviazione. Di seguito è riportato un elenco dei moduli di elaborazione.
Il modulo di elaborazione SDHash viene utilizzato per calcolare un hash di similarità della risposta HTTP. La dimensione minima del contenuto deve essere di 512 byte per poter calcolare con successo un hash. Questo è probabilmente il modulo di elaborazione più complicato da installare, poiché richiede Protobuf e, a seconda dell'host di destinazione, deve essere ricompilato. Pertanto, questo modulo di elaborazione è disattivato per impostazione predefinita. Una versione già compilata si trova in crawler/processing/minisdhash/ che richiede protobuf-2.5.0 e python3.6. Questi binari sono stati compilati su un sistema Ubuntu 18.04.5 LTS x64. Seguendo le istruzioni di installazione:
# Protobuf installation
> apt-get update
> apt-get -y install libssl-dev libevent-pthreads-2.1-6 libomp-dev g++
> apt-get -y install autoconf automake libtool curl make g++ unzip
> wget https://github.com/protocolbuffers/protobuf/releases/download/v2.5.0/protobuf-2.5.0.zip
> unzip protobuf-2.5.0.zip
> cd protobuf-2.5.0
> ./configure
> make
> sudo make install
# Python3.6 installation
> apt-get install python3.6-dev
> sudo ldconfig
# SDHash installation
> git clone https://github.com/sdhash/sdhash.git
> cd sdhash
> make
> make install
> ldconfig
JARM è uno strumento che crea impronte digitali delle connessioni TLS, sviluppato da Salesforce. Il modulo di elaborazione JARM esegue una scansione del dominio e restituisce un hash JARM con il dominio al motore principale. A seconda della configurazione di un server web, l'handshake TLS ha proprietà diverse. Calcolando un hash degli attributi di questo handshake, queste differenze possono essere utilizzate per tracciare le configurazioni del server web.
Il modulo di elaborazione TLSH è simile al modulo di elaborazione SDHash, utilizzato per calcolare un hash di similarità. Il vantaggio di TLSH è che l'installazione è molto più semplice e l'input minimo è più piccolo, pari a 50 byte. Poiché la maggior parte dei login di webshell sono piuttosto piccoli e sono stati il focus della nostra ricerca, abbiamo attivato questo modulo di elaborazione per impostazione predefinita.
Il modulo di elaborazione YARA viene utilizzato per scansionare il contenuto della risposta HTTP con regole YARA. Per richiamare questo modulo di elaborazione, fornisci il valore YARAProcessing come argomento del modulo di elaborazione. Ad esempio, il comando seguente caricherà il modulo di elaborazione YARA e produrrà l'output sulla console tramite il modulo di archiviazione ConsoleStorage.
python3 subcrawl.py -p YARAProcessing -s ConsoleStorage
Attualmente, il modulo di elaborazione YARA viene utilizzato per identificare i login di webshell e vari altri contenuti interessanti. Le regole YARA incluse in questo progetto:
Esempio di output:
Per aggiungere regole YARA aggiuntive, puoi aggiungere file .YAR alla cartella yara-rules, quindi includere il file delle regole aggiungendo un'istruzione include a combined-rules.yar.
Il modulo di elaborazione ClamAV viene utilizzato per scansionare il contenuto della risposta HTTP durante la scansione con ClamAV. Se viene trovata una corrispondenza, questa viene fornita ai vari moduli di output. Per richiamare questo modulo di elaborazione, fornisci il valore ClamAVProcessing come argomento del modulo di elaborazione. Ad esempio, il comando seguente caricherà il modulo di elaborazione ClamAV e produrrà l'output sulla console tramite il modulo di archiviazione ConsoleStorage.
python3 subcrawl.py -p ClamAVProcessing -s ConsoleStorage
Esempio di output:
Per utilizzare questo modulo, è necessario installare ClamAV. Da un terminale, installa ClamAV utilizzando il gestore pacchetti APT:
$ sudo apt-get install clamav-daemon clamav-freshclam clamav-unofficial-sigs
Una volta installato, il servizio di aggiornamento ClamAV dovrebbe già essere in esecuzione. Tuttavia, se desideri aggiornare manualmente utilizzando freshclam, assicurati che il servizio sia fermo:
sudo systemctl stop clamav-freshclam.service
Quindi esegui freshclam manualmente:
$ sudo freshclam
Infine, verifica lo stato del servizio ClamAV:
$ sudo systemctl status clamav-daemon.service
Se il servizio non è in esecuzione, puoi utilizzare systemctl per avviarlo:
$ sudo systemctl start clamav-daemon.service
Il modulo di elaborazione Payload viene utilizzato per identificare il contenuto della risposta HTTP utilizzando la libreria libmagic. Inoltre, SubCrawl può essere configurato per salvare contenuti di interesse, come file PE o archivi. Per richiamare questo modulo di elaborazione, fornisci il valore PayloadProcessing come argomento del modulo di elaborazione. Ad esempio, il comando seguente caricherà il modulo di elaborazione Payload e produrrà l'output sulla console:
python3 subcrawl.py -p PayloadProcessing -s ConsoleStorage
Non ci sono dipendenze aggiuntive per questo modulo.
Esempio di output:
I moduli di archiviazione vengono chiamati dal motore SubCrawl dopo che tutti gli URL nella coda sono stati scansionati. Sono stati progettati con due obiettivi in mente. In primo luogo, ottenere i risultati della scansione immediatamente dopo aver terminato la coda di scansione e, in secondo luogo, consentire l'archiviazione e l'analisi a lungo termine. Pertanto, abbiamo implementato non solo un modulo ConsoleStorage, ma anche un'integrazione per MISP e un modulo di archiviazione SQLite.
Per analizzare rapidamente i risultati subito dopo la scansione degli URL, viene stampato un output ben formattato sulla console. Questo output è più adatto quando SubCrawl viene utilizzato in modalità run-once. Sebbene questo approccio funzioni bene per la scansione di singoli domini o per la generazione di output rapidi, è poco maneggevole per la ricerca e l'analisi a lungo termine.
È disponibile anche l'integrazione con un cluster Elastic. Ogni URL insieme ai suoi dati verrà indicizzato come un evento, includendo l'output di altri moduli come Yara. È stata anche aggiunta una dashboard predefinita per iniziare a utilizzare questo modulo. È necessario aggiornare la sezione elasticsearch, che includerà:
Per utilizzare questo modulo di output, fornisci il valore ElasticStorage con l'argomento -s.
Poiché l'installazione e la configurazione di MISP possono richiedere tempo, abbiamo implementato un altro modulo che memorizza i dati in un database SQLite. Per presentare i dati all'utente in modo semplice e chiaro, abbiamo anche sviluppato una semplice GUI web. Utilizzando questa applicazione web, i domini e gli URL scansionati possono essere visualizzati e cercati con tutti i loro attributi. Poiché questa è solo una versione iniziale, non sono state ancora implementate funzionalità complesse di confronto.
MISP è una piattaforma di threat intelligence open source con un modello dati flessibile e un'API per memorizzare e analizzare i dati delle minacce. SubCrawl memorizza i dati raccolti in eventi MISP, pubblicando un evento per dominio e aggiungendo eventuali directory aperte identificate come attributi. MISP consente inoltre agli utenti di definire tag per eventi e attributi. Ciò è utile per il confronto degli eventi e le analisi dei collegamenti. Poiché questo era uno dei nostri principali obiettivi di ricerca, abbiamo arricchito i dati di URLHaus durante l'esportazione dell'output di SubCrawl in MISP. URLHaus annota i suoi dati utilizzando tag che possono essere utilizzati per identificare una famiglia di malware o un attore di minacce associato a un URL. Per ogni URL di directory aperta, il modulo interroga i dati URLHaus memorizzati localmente e aggiunge i tag URLHaus all'evento MISP se corrispondono. Per evitare una raccolta di attributi non correlati per ogni evento MISP, abbiamo creato un nuovo oggetto MISP per gli URL scansionati, chiamato opendir-url. Ciò garantisce che gli attributi correlati siano mantenuti insieme, facilitando la visualizzazione dei dati.
I template per i moduli di elaborazione e archiviazione sono forniti come parte del framework.
I moduli di elaborazione si trovano in crawler->processing e in questa directory si trova un file di esempio example_processing.py. Il template fornisce l'ereditarietà e le importazioni necessarie per garantire l'esecuzione da parte del framework. La funzione init fornisce l'inizializzazione del modulo e riceve un'istanza del logger e della configurazione globale. Il logger viene utilizzato per fornire informazioni di registrazione dai moduli di elaborazione, così come in tutto il framework.
La funzione process è implementata per elaborare ogni risposta HTTP. A tal fine, riceve l'URL e il contenuto grezzo della risposta. Qui viene implementato il lavoro del modulo. Questa funzione dovrebbe restituire un dizionario con i seguenti campi:
Deve essere definito un nome di classe univoco, utilizzato per definire questo modulo quando viene incluso tramite l'argomento -p o come modulo di elaborazione predefinito nel file di configurazione.
Infine, aggiungi un'istruzione di importazione in __init__.py, utilizzando il nome della tua classe:
from .<REPLACE>_processing import <REPLACE>Processing
I moduli di archiviazione si trovano in crawler->storage e in questa directory si trova un file di esempio example_storage.py. Similmente ai moduli di elaborazione, la funzione init fornisce l'inizializzazione del modulo e riceve un'istanza del logger e della configurazione globale. La funzione store_results riceve dati strutturati dal motore a intervalli definiti dalla dimensione del batch nel file di configurazione.
Deve essere definito un nome di classe univoco, utilizzato per caricare il modulo quando viene incluso tramite l'argomento -s o come modulo di elaborazione predefinito nel file di configurazione.
2021:
SubCrawl è concesso in licenza sotto la licenza MIT