Sei sulla pagina 1di 35

Documentazione per il run della soluzione ThePhish

Emanuele Galdi
Gianmarco Porcile
Alberto Vaccaro
Bernardina Bencivenga
Indice
Indice ............................................................................................................................................... II
ThePhish - Phishing E-mails Analyzer ............................................................................................ 3
Capitolo 1: Piattaforma basata su TheHive, Cortex e MISP............................................................ 4
1.1 TheHive .................................................................................................................................. 4
1.2 Cortex ..................................................................................................................................... 5
1.3 MISP ...................................................................................................................................... 6
1.3 Interazione tra i componenti .................................................................................................. 7
Capitolo 2: Implementazione ........................................................................................................... 9
Capitolo 3: Flusso logico di esecuzione ......................................................................................... 13
Capitolo 4 : Installazione ............................................................................................................... 16
4.1 Creazione macchine ............................................................................................................. 16
4.2 Installazione TheHive .......................................................................................................... 17
4.3 Installazione MISP ............................................................................................................... 21
4.4 Installazione Cortex ............................................................................................................. 23
4.5 Integrazione TheHive-Cortex .............................................................................................. 28
4.6 Integrazione TheHive-MISP ................................................................................................ 29
4.7 Setup WebServer.................................................................................................................. 32
Conclusioni .................................................................................................................................... 34
Sviluppi Futuri ............................................................................................................................... 35
Bibliografia .................................................................................... Error! Bookmark not defined.
Inserire il titolo della tesi di laurea come intestazione

ThePhish - Phishing E-mails Analyzer

Le mail di phishing sono uno dei metodi di attacco più diffusi e prevedono solitamente l'invio di
mail apparentemente provenienti da enti trusted ma che in realtà nascondono link che portano a siti
volti a rubare le credenziali di accesso di una vittima, oppure a far aprire allegati malevoli in grado
di compromettere la sicurezza della macchina della vittima.
La soluzione ThePhish si propone di essere uno strumento per l'automatizzazione dell'analisi di
mail di phishing segnalate da utenti all'interno di un'azienda.
Se utilizzata all'interno di un SOC, permetterà all'analista di velocizzare di molto il suo lavoro,
riducendo il tempo di analisi di una mail da molte ore a qualche minuto.

3
Capitolo 1: Piattaforma basata su TheHive, Cortex e MISP

ThePhish si basa principalmente sugli strumenti open source TheHive (a cui è ispirato il nome),
Cortex e MISP.

1.1 TheHive

TheHive è una piattaforma di risposta a incidenti di sicurezza che facilita il lavoro dei SOC e in
generale di chiunque voglia portare a termine investigazioni di tali incidenti.
Così come accade nelle reali investigazioni, dove viene aperto un caso e vengono svolte varie
mansioni, ivi comprese anche tutte le analisi necessarie, allo stesso modo con TheHive è possibile
aprire un caso relativo a un incidente di sicurezza.
Nell'ambito di un caso è possibile creare varie mansioni, chiamate task, che aiutano a tener traccia
delle azioni svolte sul caso nelle sue diverse fasi.

4
In una prima fase si possono identificare le informazioni che possono essere utili all'indagine, per
poi passare all'analisi di tali informazioni, e fornire infine un verdetto.
In questo contesto l'oggetto di indagine principale sarà la mail di phishing, le informazioni da
analizzare saranno alcuni dei dati in essa contenuti, mentre il verdetto sarà la classificazione della
mail come malevola o meno.
I dati in questione potranno essere ad esempio indirizzi IP, link, file allegati e indirizzi e-mail. Essi
sono chiamati observables.

1.2 Cortex

Così come un investigatore ha i propri strumenti per effettuare le sue analisi, allo stesso modo
TheHive può basarsi su tanti diversi strumenti di analisi automatica, chiamati analyzers, che può
utilizzare attraverso un componente intermedio chiamato Cortex.
Cortex permette di unificare il modo di accedere a tanti diversi strumenti, come strumenti di analisi
antivirus, analisi di allegati, etc, senza necessità di configurare separatamente ciascuno di essi,
semplificando di molto il compito dell'analista. Fornisce infatti una interfaccia comune verso tutti
questi strumenti.
Esso fornisce inoltre anche dei cosiddetti responders, che sono strumenti che possono reagire a
determinati eventi, stimolati ad esempio tramite TheHive, ed effettuare un'azione al posto
dell'analista, semplificandone ancora di più il compito, come ad esempio mandare una mail di
responso relativa a un caso chiuso.
5
1.3 MISP

In un'investigazione però c'è anche bisogno di un archivio dove inserire le informazioni relative a
casi già analizzati.
Il corrispettivo informatico nella nostra architettura è MISP, che sta per Malware Information
Sharing Platform, ossia una piattaforma di condivisione di informazioni sulle minacce informatiche
ed eventi relativi a incidenti di sicurezza, ossia una piattaforma di threat intelligence.
Un ulteriore vantaggio che offre MISP è quello di poter scegliere con chi condividere tali
informazioni, magari mantenendole nell'ambito della propria organizzazione, oppure di
condividerle con una serie di altre organizzazioni in maniera collaborativa.

6
1.3 Interazione tra i componenti

Quindi, ricapitolando, l'architettura completa è basata sull'interazione di questi 3 elementi, dove


TheHive è l'elemento principale, il quale si serve di Cortex per utilizzare gli strumenti di analisi e
di MISP sia per consultare informazioni su eventi già accaduti, sia per memorizzare e condividere
informazioni relative ad eventi appena osservati.
Per utilizzare tale architettura l'analista dovrebbe:
 leggere attentamente la mail
 selezionare i dati che ritiene importanti per l'analisi (observables)
 creare un caso su TheHive con i relativi task
 mandare una mail di presa in carico all'utente
 inserire uno ad uno gli observables su TheHive
 avviare l'analisi tramite cortex, manualmente per ciascuno di essi, per ogni analyzer
 attendere il risultato fornito da ogni strumento per ogni observable
 verificare e comparare tutti i risultati

7
 decidere se si tratta di una mail malevola o meno
 andare manualmente a pubblicare l'evento su MISP
 mandare una mail di responso all'utente
Per fare tutto questo sono necessarie ore e tanta concentrazione.
Grazie a ThePhish è possibile ridurre tale tempo a pochi minuti nella stragrande maggioranza dei
casi. Esso infatti facilita di molto il compito dell'analista, in quanto mette a disposizione
un’interfaccia grafica dalla quale egli può ottenere l'elenco delle e-mail da analizzare, avviare
l'analisi e ottenere un verdetto in pochi minuti, a fronte delle diverse ore che ci sarebbero volute per
fare il tutto manualmente.

8
Capitolo 2: Implementazione

Per implementare la soluzione ThePhish si è scelto di utilizzare principalmente il linguaggio di


programmazione Python 3, in quanto sia TheHive che Cortex mettono a disposizione delle API in
tale linguaggio chiamate rispettivamente TheHive4Py e Cortex4py.
Per l'interfacciamento con la casella di posta gmail, la lettura degli observables dalla mail e la
creazione del caso su TheHive ci si è appoggiati su una soluzione open source chiamata
"imap2thehive", reperibile su GitHub al seguente url:
https://github.com/xme/dockers/tree/master/imap2thehive
Tale strumento prevede uno script python "imap2thehive.py" che effettua le suddette operazioni,
interagendo con il protocollo IMAP e utilizzando delle regex per estrarre i dati dalle mail lette, per
poi inserire tali dati in un caso su TheHive tramite le relative API.
Prevede inoltre l'utilizzo di un file di configurazione "imap2thehive.conf" contenente le
informazioni sulla casella di posta gmail da utilizzare, il nome del template del caso su TheHive e
tutte le informazioni necessarie alla creazione del caso. Si serve infine di un file "whitelists.conf"
per whitelistare degli observables da non inserire all'interno del caso creato, basato sempre su
regex.
Ovviamente "imap2thehive" è stato solo un punto di partenza, in quanto tale strumento è stato
profondamente sistemato e modificato affinché funzionasse per i nostri scopi e venissero aggiustati
i vari bug presenti.
Sono stati infatti creati due script, "imap2thehiveList.py" e "imap2thehiveCase.py" dove il primo
permette solo di leggere le mail contenenti un allegato .eml per mostrarle sulla web GUI, mentre il
secondo permette di estrarre l'allegato .eml dalla mail selezionata e di estrarne gli observables

9
creando poi il caso su TheHive.
Al termine della creazione del caso popolato con gli observables, viene avviata l'analisi della mail
tramite uno script creato ad hoc da noi.
È stato quindi creato uno script "run_analysis.py" che utilizza le API di TheHive e Cortex
(impostando opportunamente le API Key ottenute dalla GUI web di TheHive e Cortex) per
interagire con il caso su TheHive e con gli analyzers e i responders di Cortex, assumendo il caso
già creato con i relativi task e gli observables già in esso inseriti.
Tale script:
 Manda la mail di presa in carico all'utente che ha segnalato la mail, tramite un
responder di Cortex
 Lancia tutti gli analyzer compatibili con i vari observables (ivi compreso quello di
MISP)
 Ne attende i singoli verdetti
 Analizza e confronta tali verdetti per ottenere un risultato sintetico sulla mail
Se la mail risulta Safe o Malicious:
 Chiude il caso
 Invia il responso all'utente via mail, tramite un responder di Cortex
 Pubblica sul MISP un evento con gli observables ritenuti malevoli come indicatori di
compromissione
Se la mail risulta Suspicious invece lascia aperto il caso in attesa dell'intervento dell'analista.
Tale script utilizza anche il file "analyzersWeights_conf.json" contenente i pesi da dare ai diversi
analyzer che regolano il comportamento dell'algoritmo che fornisce il responso.
Per utilizzarlo bisogna inserire, seguendo il formato json impostato, gli analyzer che si vuole
attivare (al momento sono presenti quelli attivati per la demo) e bisogna rimuovere quelli non più
utilizzati, disattivandoli anche da Cortex.
Contiene inoltre un valore che definisce qual è la soglia di peso al di sopra della quale un analyzer è
abbastanza importante ed affidabile, da fornire come verdetto che la mail sia malevola anche senza
considerare gli altri.
Affinché il tutto possa funzionare, abbiamo dovuto modificare le api di TheHive (thehive4py) in

10
modo da supportare le funzionalità di esecuzione di un responder e di esportazione dell'evento su
MISP tramite API.
In particolare, per la funzione di esecuzione del responder è stato preso spunto dalla seguente pull
request:
https://github.com/TheHive-
Project/TheHive4py/pull/108/commits/66b45be2d162bc27873eb23e2a7e873cad664de2
Essa purtroppo non è stata accettata in quanto utilizza delle parti deprecate in vista dell'uscita della
nuova versione di TheHive, inoltre presenta dei piccoli bug.
È stata quindi leggermente modificata per fixare tali bug, mentre è in programma una più profonda
modifica di tale funzione affinché possa essere accettata per l'inserimento in TheHive in una
successiva pull request.
Per quanto riguarda invece la funzione dell'esportazione su MISP, questa è stata scritta ex novo
dopo aver studiato attentamente la struttura delle API offerte da TheHive ed è stata anche effettuata
una pull request (al momento ancora aperta) al seguente link:
https://github.com/TheHive-Project/TheHive4py/pull/187
Per tali motivi abbiamo fornito il file "api.py" modificato all'interno della cartella "webthehive" da
utilizzare per l'installazione.
Sono stati inoltre modificati alcuni analyzer di Cortex in quanto presenti alcuni bug ed è in
programma la stesura di opportune pull request con relativa replica di tali bug. Per altri analyzer,
invece, sono state fatte delle modifiche semplicemente per adattarli ai nostri scopi, e quindi non
necessitano di una pull request.
Per tale motivo sono stati forniti i file da modificare in fase di installazione sulla macchina Cortex.
Si è inoltre notato che molti analyzer non seguono un pattern comune per quanto riguarda il
responso, quindi per uniformarli tutti è stato fornito un file "condition_working_analyzer.txt" che
contiene un esempio di come scrivere la funzione "summary()" all'interno degli analyzer affinché il
responso sia compatibile con la piattaforma ThePhish. Per alcuni analyzer, come già detto, queste
modifiche sono state già apportate e ne sono forniti i files, ma è a cura di chi vuole attivarne di
nuovi verificare che tale struttura venga rispettata.
Per quanto riguarda il web server, esso è stato realizzato mediante il framework Flask in Python.

11
Il file "flask_server.py" fornisce la pagina web dinamica "index.html" da noi creata, con il quale
l'analista può interagire per elencare le mail ed analizzarle.
Tale pagina utilizza AJAX per effettuare delle richieste asincrone verso il web server il quale
avvierà le funzioni contenute in "imap2thehiveList.py", "imap2thehiveCase.py" e
"run_analysis.py".
Per far sì che il web server sia robusto è stato inoltre utilizzato il modulo "mod_wsgi" del web
server apache che si interfaccia con il web server Flask.
Sarà solo necessario copiare la cartella "webthehive" per intero nel percorso specificato nella guida
di installazione, dopo aver seguito le istruzioni relative.

12
Capitolo 3: Flusso logico di esecuzione

Il flusso di esecuzione è il seguente:


 Un attaccante invia delle mail di phishing ad un bacino di utenti
 Un attaccante invia delle mail di phishing a un bacino di utenti
 L'utente riceve una mail sospetta e decide di farla analizzare dal SOC
Per farlo deve scaricare l'e-mail originale in formato .eml e inviarla come allegato alla casella di
posta gmail gestita dal SOC con la quale la piattaforma si interfaccia.
 L'analista del SOC utilizza l'interfaccia grafica web-based offerta da THEPHISH, che
si collega alla casella di posta contenente le mail, per elencare le e-mail da analizzare e
ne seleziona una per l'analisi

13
 Dietro le quinte, THE PHISH:
- invia automaticamente una e-mail all'utente per segnalare la presa in carico
della sua e-mail sospetta
- si collega a THEHIVE e crea il caso con i relativi task
- estrae dalla e-mail i cosiddetti observables, ossia i dati e gli allegati rilevanti
per l'analisi
- utilizza CORTEX per lanciare i diversi analyzer su dati e allegati
- controlla su MISP se ci sono incidenti di sicurezza nei quali sono già stati
osservati i dati contenuti nella mail
- attende il responso fornito da ogni analyzer
- utilizza un algoritmo basato su livelli di importanza dati a ciascun analyzer per
fornire automaticamente un verdetto finale sulla mail sulla base dei verdetti
- se il verdetto è definitivo:
 viene inviata una mail all'utente con il verdetto
 il caso viene chiuso
 se la mail è classificata come malevola, crea un evento su MISP
- se il verdetto non è definitivo, si richiede l'intervento dell'analista che può
accedere a TheHive, Cortex e MISP e consultare le informazioni sull'analisi in
corso
Nel caso in cui il verdetto sia definitivo, l'analista può semplicemente a passare all'analisi della
mail successiva.
In caso contrario, l'analista potrà utilizzare i pratici bottoni per andare su TheHive ed analizzare
tutti i vari report degli analyzer.
Una volta su TheHive, egli si troverà davanti il caso ancora aperto, ma avrà già a disposizione i
risultati delle singole analisi effettuate sui dati ottenuti dalla mail.
Cliccando sui nomi degli analyzer sarà possibile vederne il report dettagliato.
Nel caso in cui alcuni di questi dati vengano reputati dall'analista come malevoli, egli potrà
marcarli come indicatori di compromissione, ossia elementi che indicano che c'è stata una
compromissione, un attacco.

14
A questo punto egli può marcare la mail come malevola, scrivendo un responso all'utente nella
descrizione del task di responso e attivando il responder Mailer di Cortex che utilizzerà l'indirizzo
e-mail dell'utente che ha effettuato la segnalazione (già impostato in maniera automatica)
mandandogli la mail con il testo scritto dall'analyzer.
L'analista a questo punto può chiudere il caso ed esportare il caso su MISP tramite una comoda
funzione di esportazione (Share), che provvederà a creare l'evento.
Il vantaggio fondamentale dell'esportazione su MISP è che, se magari questa mail è stata inviata a
più utenti e arriva più volte al SOC, la seconda volta che questa viene analizzata sarà classificata
come malicious, non richiedendo più l'intervento dell'analista, grazie alle informazioni che
THEPHISH ricava da MISP, precedentemente inserite dall'analista.

15
Capitolo 4 : Installazione

ATTENZIONE: Per la guida è stato preso spunto da una guida già esistente, che è però stata
modificata in alcune parti in modo da poter funzionare con le nostre esigenze.
Riferirsi a tale guida solo per la parte visiva e grafica, mentre per i comandi seguire quelli che
verranno descritti di seguito.
La guida è al seguente link: https://blog.agood.cloud/posts/2019/04/22/building-thehive/

4.1 Creazione macchine

È consigliata, per l’installazione di questa piattaforma, un insieme di macchine ec2 su AWS. In


particolare per THEHIVE:
 cliccare “avvia istanza” e selezionare Ubuntu Server 18.04 LTS;
 selezionare “t2.large”. In basso a destra cliccare su Next;
 Cliccare su “next: add storage” in basso a destra;
 Modificare il campo “size” in “30” (gb del volume della macchina);
 Cliccare in basso a destra “next: add tags”;
 Volendo è possibile aggiungere un tag per identificare la macchina;
 Cliccare in basso a destra “next: configure security group”;
 Assicurarsi che sia presente la regola SSH sulla porta 22 con Origine: ovunque

16
 Inserire le seguenti regole:
1) HTTP, Porta 80, Origine: ovunque;
2) Regola TCP Personalizzata, Porta 9000, Origine: ovunque;
3) HTTPS, Porta 443, Origine: ovunque.
 Cliccare in basso a destra “review and launch”;
 Scegliere la chiave da usare per la connessione SSH.

La stessa procedura deve essere seguita per le istanze di Cortex e MISP ma con le seguenti
modifiche:

CORTEX:

- Al punto 2) delle regole del security group della lista precedente inserire:
1) Regola TCP Personalizzata, Porta 9001, Origine: ovunque

MISP:

- Modificare il campo “size” in 50gb (non 30);


- Non inserire la regola al punto 2) nelle regole del security group della lista principale.

WEBSERVER:

- Selezionare istanza “t2.medium” al posto di “t2.large”;


- Potrebbero essere sufficienti 8gb di volume;
- Al punto 2) delle regole del security group della lista principale inserire:
1) Regola TCP personalizzata, Porta 5000, Origine: ovunque.

4.2 Installazione TheHive

17
Andiamo ad installare TheHive sulla prima macchina creata. Accediamo tramite SSH alla
macchina.
Aggiorniamo il sistema appena installato:
$ sudo apt-get update && sudo apt-get upgrade
Riavviamo la macchina.
Eseguiamo i seguenti comandi:
$ sudo add-apt-repository ppa:openjdk-r/ppa
$ sudo apt-get update
$ sudo apt-get install openjdk-8-jre-headless
$ sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --
recv-key D88E42B4
$ echo "deb https://artifacts.elastic.co/packages/5.x/apt stable
main" | sudo tee -a /etc/apt/sources.list.d/elastic-5.x.list
$ sudo apt install apt-transport-https
Apriamo il file /etc/elasticsearch/elasticsearch.yml per la modifica (ad esempio con nano).
Inseriamo alla fine del file le seguenti righe:

network.host: 127.0.0.1
script.inline: true
cluster.name: hive
thread_pool.index.queue_size: 100000
thread_pool.search.queue_size: 100000
thread_pool.bulk.queue_size: 100000

Chiudiamo il file salvandolo.


Eseguiamo i seguenti comandi per abilitare e lanciare elasticsearch:
$ sudo systemctl enable elasticsearch.service
$ sudo systemctl start elasticsearch.service
$ sudo systemctl status elasticsearch.service

Procediamo con la preparazione e l’installazione di TheHive.


$ sudo apt-get install unzip
$ cd /opt
$ sudo wget https://dl.bintray.com/thehive-project/binary/thehive-
latest.zip
$ sudo unzip thehive-latest.zip
Verificare il numero dell’ultima versione di TheHive (al momento della scrittura di questa guida la

18
versione è la n. 3.4.2-1
Inserire il numero versione nel prossimo comando al posto di “NUMERO-VERSIONE”
$ sudo ln -s thehive-NUMERO-VERSIONE thehive
Modificare il file /opt/thehive/package/thehive.service alla riga “ExecStart=…” in:

ExecStart=/opt/thehive/bin/thehive \
-Dconfig.file=/opt/thehive/conf/application.conf \
-Dlogger.file=/opt/thehive/conf/logback.xml \
-Dpidfile.path=/dev/null

Chiudere salvando il file.


Eseguire il seguente comando per generare la secret key:
$ (cat << _EOF_
# Secret key
# ~~~~~
# The secret key is used to secure cryptographics functions.
# If you deploy your application to several instances be sure to
use the same key!
play.http.secret.key="$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' |
fold -w 64 | head -n 1)"
_EOF_
) | sudo tee -a /opt/thehive/conf/application.conf
Completare la configurazione eseguendo i comandi seguenti:
$ sudo addgroup thehive
$ sudo adduser --system thehive
$ sudo cp /opt/thehive/package/thehive.service
/usr/lib/systemd/system
$ sudo chown -R thehive:thehive /opt/thehive
$ sudo chgrp thehive /opt/thehive/conf/application.conf
$ sudo chmod 640 /opt/thehive/conf/application.conf
$ sudo systemctl enable thehive
$ sudo service thehive start
Andare all’indirizzo IP di TheHive sulla porta 9000 (http://IP_MACCHINA_THEHIVE:9000) e
fare l’update del database e la creazione dell’utente prima del primo accesso.

Creare un case template che servirà per la soluzione ThePhish navigando su Admin > Case
Templates e creare un template con nome "pw3_phishing" e con 3 task:
- Notify
19
- Analysis
- Result

INSTALLAZIONE CERTIFICATI THE HIVE

Finora si è utilizzato il protocollo http per accedere a THEHIVE.


È consigliabile inserire dei certificati per rendere possibile l'utilizzo del protocollo https. Per fare
ciò si utilizza nginx per effettuare una procedura di reverse proxy.
Prima di procedere è necessario creare un proprio dominio, ad esempio
"thehive.projectwork3.cyberhackademy.it".

Installiamo nginx:
$ sudo apt install nginx
Installiamo certbot e generiamo i certificati:
$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
$ sudo certbot --nginx
Configuriamo nginx:
$ sudo systemctl start nginx
$ sudo systemctl enable nginx
$ sudo mkdir /etc/nginx/ssl
$ sudo cp
/etc/letsencrypt/live/thehive.projectwork3.cyberhackademy.it/cert.
pem /etc/nginx/ssl/thehive_cert.pem
$ sudo cp
/etc/letsencrypt/live/thehive.projectwork3.cyberhackademy.it/privk
ey.pem /etc/nginx/ssl/thehive_key.pem
$ nginx -t
Eliminare il file "/etc/nginx/sites-enabled/000-default-ssl.conf"

Creiamo il file "/etc/nginx/sites-enabled/thehive.conf" con la seguente configurazione:

server {
listen 80;
server_name thehive.projectwork3.cyberhackademy.it;

20
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl;
server_name thehive.projectwork3.cyberhackademy.it;

ssl on;
ssl_certificate ssl/thehive_cert.pem;
ssl_certificate_key ssl/thehive_key.pem;

proxy_connect_timeout 600;
proxy_send_timeout 600;
proxy_read_timeout 600;
send_timeout 600;
client_max_body_size 2G;
proxy_buffering off;
client_header_buffer_size 8k;

location / {
add_header Strict-Transport-Security "max-age=31536000;
includeSubDomains";
proxy_pass http://127.0.0.1:9000/;
proxy_http_version 1.1;
}
}

Riavviare i servizi thehive, elasticsearch e nginx.

4.3 Installazione MISP

21
Accediamo tramite SSH alla macchina di MISP che abbiamo creato. Eseguiamo i seguenti
comandi:
$ sudo apt-get update && sudo apt-get upgrade && sudo reboot now
$ wget -O /tmp/INSTALL.sh
https://raw.githubusercontent.com/MISP/MISP/2.4/INSTALL/INSTALL.sh
$ bash /tmp/INSTALL.sh -c
Modifichiamo il file "/etc/apache2/sites-enabled/misp-ssl.conf" inserendo il nostro dominio, ad
esempio "misp.projectwork3.cyberhackademy.it"

Installiamo certbot e generiamo i certificati:


$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
$ sudo certbot --apache
Accedere tramite https all'url su cui è in ascolto MISP e inserire
Username: admin@admin.test
Password: admin

Navighiamo su Administration > Add Organization


Inseriamo il nome dell'organizzazione
Generiamo l'UUID
Clicchiamo Submit

Navighiamo su Administration > Server Settings and Maintenance


Nei MISP settings aggiorniamo i seguenti settaggi facendo doppio click sul valore:

MISP.baseurl https://misp.projectwork3.cyberhackademy.it
MISP.external_base_url https://misp.projectwork3.cyberhackademy.it
MISP.org Nome organizzazione
MISP.host_org_id Nome organizzazione
MISP.welcome_text_top messaggio
MISP.welcome_text_bottom messaggio

22
Per scaricare i feed di MISP andare su Sync Actions > List Feeds > List default feed metadata.
Selezionare i feed da utilizzare e cliccare Enable feeds e poi su Fetch and store all feed data.

4.4 Installazione Cortex

Accediamo tramite SSH alla macchina di Cortex che abbiamo creato. Eseguiamo i seguenti
comandi:
$ sudo apt-get update && sudo apt-get upgrade -y
$ sudo add-apt-repository ppa:openjdk-r/ppa
$ sudo apt-get update
$ sudo apt-get install openjdk-8-jre-headless
$ sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --
recv-key D88E42B4
$ echo "deb https://artifacts.elastic.co/packages/5.x/apt stable
main" | sudo tee -a /etc/apt/sources.list.d/elastic-5.x.list
$ sudo apt install apt-transport-https
$ sudo apt update && sudo apt install elasticsearch
$ sudo su
$ nano /etc/elasticsearch/elasticsearch.yml
Aggiungere le seguenti righe alla fine del file:

network.host: 127.0.0.1
script.inline: true
cluster.name: hive
thread_pool.index.queue_size: 100000
thread_pool.search.queue_size: 100000
thread_pool.bulk.queue_size: 100000

$ sudo systemctl enable elasticsearch.service


$ sudo systemctl start elasticsearch.service
$ sudo systemctl status elasticsearch.service
Ritornare l’utente precedente:
$ exit
Installare e verificare Cortex
$ cd /opt

23
$ sudo wget https://raw.githubusercontent.com/TheHive-
Project/cortex/master/PGP-PUBLIC-KEY
$ gpg --import PGP-PUBLIC-KEY
$ sudo apt-get install unzip
$ sudo wget https://dl.bintray.com/thehive-project/binary/cortex-
2.1.3-1.zip
$ sudo wget https://dl.bintray.com/thehive-project/binary/cortex-
2.1.3-1.zip.asc
$ sudo unzip cortex-2.1.3-1.zip
$ sudo ln -s cortex-2.1.3-1 cortex
Modificare il file /opt/cortex/package/cortex.service (ad esempio con nano) alla riga “ExecStart=..”
in:

ExecStart=/opt/cortex/bin/cortex \
-Dconfig.file=/opt/cortex/conf/application.conf \
-Dlogger.file=/opt/cortex/conf/logback.xml \
-Dpidfile.path=/dev/null

$ sudo mv /opt/cortex/conf/application.sample
/opt/cortex/conf/application.conf
$ (cat << _EOF_
# Secret key
# ~~~~~
# The secret key is used to secure cryptographics functions.
# If you deploy your application to several instances be sure to
use the same key!
play.http.secret.key="$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' |
fold -w 64 | head -n 1)"
_EOF_
) | sudo tee -a /opt/cortex/conf/application.conf
$ sudo addgroup cortex
$ sudo adduser --system cortex
$ sudo cp /opt/cortex/package/cortex.service
/usr/lib/systemd/system
$ sudo chown -R cortex:cortex /opt/cortex
$ sudo chown -R cortex:cortex /opt/cortex-2.1.3-1
$ sudo chgrp cortex /opt/cortex/conf/application.conf
$ sudo chmod 640 /opt/cortex/conf/application.conf
$ sudo systemctl enable cortex
$ sudo service cortex start
Una volta completata l'installazione accedere all'IP di cortex sulla porta 9001
(http://IP_SERVER_CORTEX:9001)
Fare l'update del database e creare un utente.

24
Una volta fatto il login come superadmin con l'utente appena creato bisogna creare
un'organizzazione navigando su Organizations > Add Organization riempiendo i campi:

Name: NOME DELL'ORGANIZZAZIONE


Description: DESCRIZIONE DELL'ORGANIZZAZIONE

Dopo aver fatto ciò, creare un utente usando "Add user" tramite i campi:

Login: USERNAME USATO PER IL LOGIN


Full name: NOME COMPLETO DELL'UTENTE
Roles: RUOLO DELL'UTENTE ALL'INTERNO DELL'ORGANIZZAZIONE (orgadmin)

AGGIUNTA DEGLI ANALYZER A Cortex

Installare i prerequisiti:
$ sudo apt-get install -y --no-install-recommends python-pip
python2.7-dev python3-pip python3-dev ssdeep libfuzzy-dev
libfuzzy2 libimage-exiftool-perl libmagic1 build-essential git
libssl-dev
$ sudo pip install -U pip setuptools && sudo pip3 install -U pip
setuptools
Clonare la repo contenente gli analyzers:
$ cd /opt
$ sudo git clone https://github.com/TheHive-Project/Cortex-
Analyzers
$ cd /opt
$ sudo git clone https://github.com/TheHive-Project/Cortex-
Analyzers
Installare i prerequisiti dei singoli analyzer:
$ for I in $(find Cortex-Analyzers -name 'requirements.txt'); do
sudo -H pip2 install -r $I; done && \
$ for I in $(find Cortex-Analyzers -name 'requirements.txt'); do
sudo -H pip3 install -r $I || true; done
Modifichiamo il file "sudo nano /opt/cortex/conf/application.conf" inserendo al posto di "path =
["path/to/Cortex-Analyzers/analyzers"]":

25
path = ["/opt/Cortex-Analyzers/analyzers/"]

Inserire inoltre in tale file:

## RESPONDERS
#
responder {
# Directory that holds responders
path = [
"/opt/Cortex-Analyzers/responders/",
# "/path/to/my/own/responder"
]

fork-join-executor {
# Min number of threads available for analyze
parallelism-min = 2
# Parallelism (threads) ... ceil(available processors * factor)
parallelism-factor = 2.0
# Max number of threads available for analyze
parallelism-max = 4
}
}

Sostituire in "/opt/Cortex-Analyzers/analyzers" le cartelle (con tutto il loro contenuto) contenute


nella cartella "ChangedAnalyzers" fornita da noi.

Riavviamo cortex
$ sudo service cortex restart

26
Procedere alla configurazione degli analyzer che si vuole attivare effettuando il login con l'utente
con privilegi di orgadmin creato in precedenza e andare su Organizations > Analyzers.
Selezionare quindi gli analyzer a cui si è interessati e impostare i parametri caratteristici degli
stessi, come ad esempio le eventuali API key richieste.

INSTALLAZIONE CERTIFICATI CORTEX

Così come con thehive, anche per cortex bisogna settare i certificati affinché vi si possa accedere
tramite https.
Prima di procedere è necessario creare un proprio dominio, ad esempio
"cortex.projectwork3.cyberhackademy.it".

Installiamo nginx:
$ sudo apt install nginx
Installiamo certbot e generiamo i certificati:
$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
$ sudo certbot --nginx
Configuriamo nginx:
$ sudo systemctl start nginx
$ sudo systemctl enable nginx
Eliminare il file "/etc/nginx/sites-enabled/000-default-ssl.conf"

Creiamo il file "/etc/nginx/sites-enabled/cortex.conf" con la seguente configurazione:

server {
listen 80;
server_name cortex.projectwork3.cyberhackademy.it;
return 301 https://$server_name$request_uri;
}

27
server {
listen 443 ssl;
server_name cortex.projectwork3.cyberhackademy.it;

ssl on;
ssl_certificate /etc/letsencrypt/live/cortex.projectwork3.cyberhackademy.it/cert.pem;
ssl_certificate_key
/etc/letsencrypt/live/cortex.projectwork3.cyberhackademy.it/privkey.pem;

proxy_connect_timeout 600;
proxy_send_timeout 600;
proxy_read_timeout 600;
send_timeout 600;
client_max_body_size 2G;
proxy_buffering off;
client_header_buffer_size 8k;

location / {
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains";
proxy_pass http://127.0.0.1:9001/;
proxy_http_version 1.1;
}
}

Riavviare i servizi cortex e nginx.

4.5 Integrazione TheHive-Cortex

28
Loggare su Cortex con l'utente orgadmin
Creare un altro utente che farà da integration user, dandogli privilegi di read e analyze.
Una volta creato andare su Create API key e cliccare reveal.

Andare sulla macchina di TheHive


Modificare il file di configurazione "/opt/thehive/conf/application.conf" e nella sezione Cortex fare
i seguenti cambiamenti:
- Decommentare la riga "play.modules.enabled += connectors.cortex.CortexConnector"
- Modificare il fiel come segue:
cortex {
"CORTEX-SERVER" {
url = "http://cortex.projectwork3.cyberhackademy.it:9001"
key = "<API KEY>"
# HTTP client configuration (SSL and proxy)
ws {}
}
}

Riavviare thehive
$ service thehive restart
$ service thehive status
Verificare che l'integrazione sia riuscita loggando su TheHive e cliccando su Admin > About.

4.6 Integrazione TheHive-MISP

Loggare su MISP e navigare su Administration > Add User.


Creare un nuovo utente e prendere la sua authkey.
Dare all'utente il ruolo Sync, in quanto è l'utente che verrà usato per effettuare l'integrazione. Tale
authkey verrà utilizzata anche nell'abilitazione dell'analyzer relativo a MISP su Cortex.

29
Andare sulla macchina di TheHive
Cambiare il file "/opt/thehive/conf/application.conf" nel seguente modo:
# MISP
# TheHive can connect to one or multiple MISP instances. Give each MISP
# instance a name and specify the associated Authkey that must be used
# to poll events, the case template that should be used by default when
# importing events as well as the tags that must be added to cases upon
# import.

# Prior to configuring the integration with a MISP instance, you must


# enable the MISP connector. This will allow you to import events to
# and/or export cases to the MISP instance(s).

play.modules.enabled += connectors.misp.MispConnector

misp {
# Interval between consecutive MISP event imports in hours (h) or
# minutes (m).
interval = 5m

"MISP-SERVER" {
# # MISP connection configuration requires at least an url and a key. The key must
# # be linked with a sync account on MISP.
url = "https://misp.projectwork3.cyberhackademy.it"
key = "<AUTH_KEY>"
#
# # Name of the case template in TheHive that shall be used to import
# # MISP events as cases by default.
# caseTemplate = "<Template_Name_goes_here>"

30
#
# # Optional tags to add to each observable imported from an event
# # available on this instance.
# tags = ["misp"]
#
# ## MISP event filters
# # MISP filters is used to exclude events from the import.
# # Filter criteria are:
# # The number of attribute
max-attributes = 1000
# # The size of its JSON representation
max-size = 1 MiB
# # The age of the last publish date
max-age = 7 days
# # Organization and tags
# exclusion {
# organisation = ["bad organisation", "other organisations"]
# tags = ["tag1", "tag2"]
# }
#
# ## HTTP client configuration (SSL and proxy)
# # Truststore to use to validate the X.509 certificate of the MISP
# # instance if the default truststore is not sufficient.
# # Proxy can also be used
# ws {
# ssl.trustManager.stores = [ {
# path = /path/to/truststore.jks
# }]
# proxy {

31
# host = proxy.mydomain.org
# port = 3128
# }
# }
#
# # MISP purpose defines if this instance can be used to import events (ImportOnly), export
cases (ExportOnly) or both (ImportAndExport)
# # Default is ImportAndExport
# purpose = ImportAndExport
}
}

Riavviare thehive:
$ service thehive restart
$ service thehive status
Verificare che l'integrazione sia riuscita loggando su TheHive e cliccando su Admin > About.

4.7 Setup WebServer

Si suppone di avere già un dominio disponibile, come ad esempio


"web.projectwork3.cyberhackademy.it".
Accediamo tramite SSH alla macchina del webserver che abbiamo creato. Eseguiamo i seguenti
comandi:
$ sudo apt-get update && sudo apt-get upgrade -y
$ sudo apt install python3-venv
$ sudo apt install apache2
$ sudo apt-get install libapache2-mod-wsgi-py3 python-dev
$ pip install flask
Copiare la cartella "webthehive" da noi fornita con tutto il suo contenuto sotto "/var/www/html/"
Modificare tutti i file ".py" o ".conf" sostituendo le API key generate da thehive e cortex nella
nuova installazione ed eventualmente gli url per i nuovi domini.

32
Creare il file "/etc/apache2/sites-available/webthehive.conf" e inserirvi il seguente contenuto:
<VirtualHost *:80>
# Add machine's IP address (use ifconfig command)
ServerName web.projectwork3.cyberhackademy.it
# Give an alias to to start your website url with
WSGIScriptAlias / /var/www/html/webthehive/flask_server.wsgi
<Directory /var/www/html/webthehive/>
# set permissions as per apache2.conf file
Options FollowSymLinks
AllowOverride None
Require all granted
</Directory>
ErrorLog ${APACHE_LOG_DIR}/error.log
LogLevel warn
CustomLog ${APACHE_LOG_DIR}/access.log combined
RewriteEngine on
RewriteCond %{SERVER_NAME} =web.projectwork3.cyberhackademy.it
RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>

Installiamo certbot e generiamo i certificati:


$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
$ sudo certbot --apache
Eseguire i seguenti comandi:
$ sudo a2ensite webthehive.conf
$ sudo service apache2 restart

33
Conclusioni

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Integer odio augue, varius at,

34
Sviluppi Futuri

Questo strumento apre la strada a molte aggiunte possibili in futuro. Una delle cose più
significative da prendere in considerazione è sicuramente l’integrazione di nuovi analyzers, per una
percentuale di successo più alta in fase di analisi. Altro sviluppo che potrebbe risultare significativo
ai fini della riuscita immediata dell’analisi, è l’integrazione all’interno di ThePhish di regole
sintattiche, per riconoscere da subito una mail analizzata, come mail di phishing. In questo modo
l’analisi potrebbe risultare ancora più veloce, basandosi direttamente sul riconoscimento delle
regole sintattiche che compongono la mail.

35

Potrebbero piacerti anche