Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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
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
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
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
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/
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:
WEBSERVER:
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
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
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
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"
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;
}
}
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"
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.
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
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:
Dopo aver fatto ciò, creare un utente usando "Add user" tramite i campi:
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/"]
## 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
}
}
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.
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"
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;
}
}
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.
Riavviare thehive
$ service thehive restart
$ service thehive status
Verificare che l'integrazione sia riuscita loggando su TheHive e cliccando su Admin > About.
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.
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.
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>
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