Archivi tag: firewall

Sicurezza – Honeypot SSH

Kippo honeypotUn Honeypot SSH con Kippo

Chiunque abbia un minimo di esperienza nel mettere a punto server rivolti verso Internet conosce bene la quantità di scansioni e di attacchi automatizzati che si possono ricevere in brevissimo tempo, a volte nel momento stesso in cui ci si collega in Rete.

Molti scanner non sono sofisticati e si limitano a cercare porte ssh aperte per tentare un bruteforce e, in caso di successo, passare il controllo ad un attaccante umano (un cracker non un hacker).

Come descritto in un precedente articolo “Sicurezza con il PortKnocking” , i passi da fare per mettersi al sicuro non sono mai abbastanza ed inparticolare alcuni servizi vanno completamente blindati anche solo per evitare enormi moli di log del firewall, solo per i tentativi di login al servizio SSH; proprio per questi motivi un ottimo esercizio e’ quello di creare un honeypot partendo da quest’ultimo servizio.

In questo contesto si colloca Kippo: un honeypot che simula un server ssh vulnerabile il cui obiettivo è quello di impegnare un attaccante e registrarne i movimenti. E’ un tool open source scritto in Python progettato quindi per registrare attacchi di tipo bruteforce e, soprattutto, l’intera interazione shell effettuata dall’ attaccante. In pratica quando un utente malintenzionato cercherà di entrare nel vostro sistema si troverà davanti un finto sistema che registrerà tutte le sue attività.

Kippo nel tempo si è guadagnato una certa popolarità dovuta alla sua semplicità d’uso, portabilità e al fatto che permette di riprodurre i log degli attacchi registrati.

Installazione

Kippo è programmato in Python e si basa sul framework Twisted, è necessario quindi un interprete python almeno alla versione 2.5.

I requisiti sono i seguenti:

  • Python 2.5+
  • Twisted 8.0+
  • PyCrypto
  • Zope Interface

come prima cosa bisogna cambiare la porta del server SSH per fare questo basta aprire e modificare il file sshd_config:

# vim /etc/ssh/sshd_config

e sostituire la porta 22 con un’altra a vostra scelta,

Dopo aver modificato il parametro Port 22 con un altro (es. 2443) riavviare il servizio con il commando:

 # /etc/init.d/ssh restart

Una volta sistemato questo piccolo dettaglio, bisogna installare tutti i pacchetti necessari per il corretto funzionamento di Kippo:

Prima di mettere in esecuzione l’ honeypot occorre configurarlo agendo sui parametri nel file kippo.cfg.

Le principali opzioni sono le seguenti:

  • ssh_addr: l’indirizzo dell’interfaccia su cui vogliamo mettere kippo in ascolto (di default su tutte)
  • ssh_port: il numero della porta
  • password: la password per collegarsi all’ honeypot, di default è 123456 che statisticamente è la password più comune che si può trovare. Se impostiamo una password difficile rischiamo di far fallire un attacco brute force! e ci perdiamo il bello del divertimento.
  • [database_mysql]: parametri per loggare tutta l’attività di kippo su un db mysql. Di default questa opzione non è attiva.

Su Linux per motivi di sicurezza kippo non può essere eseguita come root e quindi non può mettersi direttamente in ascolto sulle porte basse del sistema (< 1024) tra cui anche quella di default del server ssh (la porta 22).

Per reindirizzare la porta 22 sulla porta in cui abbiamo messo in ascolto la honeypot dobbiamo impostare un reindirizzamento con il firewall di sistema. L’impostazione corretta dipende dal firewall che state usando sul vostro server e dalla tipologia della rete.

Ad esempio con iptables:

iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 22 -j REDIRECT --to-port 2443

oppure usando l’ottimo tool rinetd, come spiegato enll’articolo “Catturare il traffico di rete“.

Installiamo i pacchetti
# apt-get install python-dev openssl python-openssl python-pyasn1 python-twisted

Visto che la porta 22 (che kippo dovrà monitorare) può essere utilizzata solo dall’ utente root e per ragioni di sicurezza non è consigliato usare kippo come utente root bisogna installare un altra piccola applicazione, Authbind, che ci permetterà di eseguire kippo sulla porta 22:

# apt-get install authbind

Ora creiamo un altro utente (non-root) che useremmo per eseguire kippo (non è vietato eseguire kippo come root ma per ragioni di sicurezza è consigliato usare un utente apposito):

# adduser kippo

e aggiungiamolo alla lista dei sudoers:

 # vim /etc/sudoers

aggiungendo la seguente stringa nel file:

kippo ALL=(ALL:ALL) ALL

(sotto l’utente root)

 Non ci resta che dare all’ utente kippo i privilegi per usare la porta 22:

# touch /etc/authbind/byport/22
# chown kippo:kippo /etc/authbind/byport/22
# chmod 777 /etc/authbind/byport/22

Ora non ci resta che cambiare utente ed entrare nel sistema con l’utente kippo, una volta cambiato utente siamo pronti a scaricare kippo (verificare sul sito del progetto per nuove versioni):

# wget https://kippo.googlecode.com/files/kippo-0.8.tar.gz /home/<utente xxx>/Downloads/

estraiamo i file:

# tar -zxvf kippo-0.8.tar.gz -C /opt/

ora ci spostiamo nella cartella del programma e modifichiamo il file kippo.cfg inserendo la porta 22 come target (di default è impostata la 2222) con la porta da voi prescelta, tipo la 2443.

# vim kippo.cfg

ed in fine modifichiamo il file start.sh:

# vim start.sh

sostituendo la stringa:

twistd -y kippo.tac -l log/kippo.log –pidfile kippo.pid

con:

authbind –deep twistd -y kippo.tac -l log/kippo.log –pidfile kippo.pid

ora non ci resta che eseguire il programma con:

# ./start.sh

…… e qualsiasi tentativo di connettersi alla porta 22 del sistema sarà registrato da Kippo e file di log verranno archiviati nella cartella corrispondente. Kippo rimane in esecuzione in background e aspetta che qualche attaccante si faccia vivo.

Quando finalmente riusciremo a registrare un attacco (e solitamente è questione di solo poche ore!) l’honeypot si occuperà di registrare ogni movimento.

Nella cartella log/ verranno salvati i log interattivi delle sessioni registrate e in quella dl/ verranno salvati i file e gli eseguibili che gli ignari attaccanti tenteranno di scaricare sul server (di solito rootkit, malware generici, etc)

Il divertimento, una volta collezionati un po di log interattivi, è quello di riprodurli con il playlog che è una utilità che permette di riprodurre i log come se fossero un video.

Il programma si trova nella cartella utils/, per eseguirlo (da linea di comando):

python playlog.py /path/to/xxx.log

Statistiche

Quando si ha una honeypot funzionante a pieno regime può risultare scomodo controllare periodicamente i log per capire il numero di attacchi ricevuti, la durata e altre informazioni utili.

Per facilitarci le cose possiamo affidarci a un programma come Kippo Graph che si occupa di generare statistiche dettagliate e farci risparmiare del tempo prezioso.

Sicurezza con il PortKnocking

portknockingMi e’ capitato spesso di dover configurare firewall per proteggere i Server di mia competenza e molte volte capita l’esigenza di dover tenere aperto un accesso dall’esterno, per poter operare in qualunque momento o per qualunque motivo. Ovviamente questo ci potrebbe esporre facilmente alla possibilita’ di venire attaccati; che cosa fare in questi casi ??? Beh! le possibili soluzioni sono davvero tante, tante quanto la fantasia di chi le studia; in questo articolo quindi descrivero’ semplicemente un mio modo personale di arginare tale possibile pericolo.

* Il primo suggerimento e’ quello di spostare il servizio SSH dalla porta 22 ad una di vostra preferenza, stando ben attenti a non usare possibili porte utilizzabili da altri servizi web.

* Il secondo suggerimento e’ quello di creare un servizio di Honeypot (tipo honeyd a bassa interazione, oppure come honeynet ad alta interazione) , da tenere in ascolto sulla porta standard (la 22) dell’SSH, cosi’ che i male intenzionati trovino la porta attiva e nel tentativo di attaccarvi perdano tempo e si ritrovino successivamente all’interno di servizi fasulli.

* Il terzo suggerimento e’ quello di utilizzare la tecnica del port-knocking per poter gestire a proprio piacimento ogni accesso in SSH attivando e disattivando tramite una sequenza di caratteri che solo voi conoscete e che potrete cambiare a piacimento.

PORTKNOCKING

Iniziamo col dire che cosa e’ questa tecnica: le tecniche di Port knocking permettono di aumentare considerevolmente la sicurezza di un server che deve garantire alcuni servizi non permanenti attraverso IP pubblici. Se s’inviano dei pacchetti a delle porte prestabilite sulle quali il demone è in ascolto e nel caso la sequenza sia corretta, questi attiverà un comando che potrà eseguire delle regole di iptables che apriranno le porte necessarie alla connessione. Il vantaggio è notevole in quanto il server potrebbe rimanere sempre in stealth mode e aprire le porte per un determinato servizio solo in caso di necessità.

Innanzitutto per poter utilizzare il portknocking e’ necessario che il firewall sia attivo e funzionante, ora posiamo installare il pacchetto software

sudo apt-get install knockd

Configurazione knockd

  1. Per fare in modo che il demone parta all’avvio del computer modificare con un editor di testo a piacimento, e con i privilegi di amministrazione il file /etc/default/knockd in questo modo: 

    START_KNOCKD=1

     

  2. Sempre nel medesimo file /etc/default/knockd modificare con un editor di testo a piacimento, e con i privilegi di amministrazione indicando su quale interfaccia il demone dovrà rimanere in ascolto: 

    KNOCKD_OPTS="-i eth0"

     

Configurazione knockd.conf per l’apertura di una sola porta

Modificare con un editor di testo a piacimento, e con i privilegi di amministrazione il file /etc/knockd.conf impostandolo come segue: 

[options]
        logfile = /var/log/knockd.log

[openSSH]
        sequence    = 7000,8000,9000
        # Questa è la sequenza delle porte sulle quali knockd rimarrà in ascolto. Di default il protocollo è TCP.
        # Quali e quante porte usare è discrezionale.

        # sequence   = 7000:udp,8000:tcp,9000:udp
        # Esempio con sequenza con porte miste udp/tcp

        seq_timeout = 30
        #Tempo di attesa massimo per completare la sequenza.

        command     = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
        # Quando la sequenza verrà accettata verrà inserita una regola che aprirà la porta SSH standard.

        tcpflags    = syn
        # Ulteriore filtro, sul tipo di flag del pacchetto inviato alla sequenza di porte.
        
[closeSSH]
        sequence    = 9000,8000,7000
        # Questa è un'altra sequenza di porte sulle quali knockd rimarrà in ascolto.

        seq_timeout = 30

        command     = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
        # Quando la sequenza verrà accettata verrà inserita una regola che cancellerà quella creata in precedenza.

        tcpflags    = syn
        # Ulteriore filtro, sul tipo di flag del pacchetto inviato alla sequenza di porte.

La variabile «%IP%» passa alla regola di iptables l’indirizzo che ha effettuato la richiesta di connessione, in questo caso verrà permessa l’apertura della porta SSH discriminando solo l’IP validato.

Configurazione per l’apertura di una sola porta, per soli esperti

Un’altra possibilità per usare il demone knockd, e’ utilizzabile solo se il firewall sul server è configurato per accettare le connessioni “established” e “related” alla porta che si vuole aprire (es ssh, 22) è di chiudersi subito dietro la porta appena aperta, per evitare che, restando “aperta”, qualche malintenzionato tenti un brute-force al servizio, lanciando uno script anzichè impostando delle regole sul firewall.

Per questo scopo il file /etc/knockd.conf può ad esempio essere modificato, con un editor di testo a piacimento, e con i privilegi di amministrazione, come segue : 

[options]
        logfile = /var/log/knockd.log

[openSSH]
        sequence    = 7000,8000,9000
        seq_timeout = 30
        start_command     = /etc/init.d/ssh start
        tcpflags    = syn

        cmd_timeout = 5
        stop_command     = /etc/init.d/ssh stop
        # Dopo cmd_timeout secondi, viene eseguito il comando stop_command

Ricordiamo ancora che è indispensabile che il firewall sul server accetti le connessioni “related” ed “established” altrimenti la sezione “stop_command”, appena sarà eseguita, vi chiuderà la connessione SSH senza quindi avere possibilità di connettervi al server! 

tuttiperlinux@server:~# iptables -nL | grep ":22"

ACCEPT     tcp  --  0.0.0.0/0    0.0.0.0/0           tcp dpt:22
ACCEPT     tcp  --  0.0.0.0/0    0.0.0.0/0           tcp spt:22 dpts:513:65535 state RELATED,ESTABLISHED
ACCEPT     tcp  --  0.0.0.0/0    0.0.0.0/0           tcp spts:1024:65535 dpt:22 flags:0x17/0x02 state RELATED,ESTABLISHED
ACCEPT     udp  --  0.0.0.0/0    0.0.0.0/0           udp dpt:22 state ESTABLISHE

Configurazione knockd.conf per l’apertura di più porte

Nell’esempio sopra esposto si è visto come aprire una sola porta. Se l’esigenza fosse però quella di aprirne di più procedere creando più sessioni «[openServizio]» e «[closeServizio]». Questo sistema risulta però scomodo per ovvi motivi, per ottenere lo stesso risultato è consigliato usare degli script.

Modificare con un editor di testo a piacimento, e con i privilegi di amministrazione il file /etc/knockd.conf impostandolo come segue: 

[options]
        logfile = /var/log/knockd.log

[open]
        sequence    = 7000,8000,9000
        seq_timeout = 30
        tcpflags    = syn
        command     = sh /etc/open_ports %IP%


[close]
        sequence    = 9000,8000,7000
        seq_timeout = 30
        tcpflags    = syn
        command     = sh /etc/close_ports %IP%

In questo caso invece di eseguire direttamente iptables si richiamano due script passando il parametro «%IP%» alla variabile speciale «$1».

Esempio di script open_ports

Modificare con un editor di testo a piacimento, e con i privilegi di amministrazione il file /etc/open_ports impostandolo come segue: 

iptables -A INPUT -s $1 -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -s $1 -p tcp --dport 21 -j ACCEPT
iptables -A INPUT -s $1 -p tcp --dport 631 -j ACCEPT
iptables -A INPUT -s $1 -p tcp --dport 5125 -j ACCEPT
iptables -A INPUT -s $1 -p tcp --dport 5126 -j ACCEPT
iptables -A INPUT -s $1 -p tcp --dport 8888 -j ACCEPT
iptables -A INPUT -s $1 -p tcp --dport 10000 -j ACCEPT
iptables -A INPUT -s $1 -p tcp --dport 81 -j ACCEPT

Esempio di script close_ports

Modificare con un editor di testo a piacimento,  e con i privilegi di amministrazione il file /etc/close_ports impostandolo come segue: 

iptables -D INPUT -s $1 -p tcp --dport 22 -j ACCEPT
iptables -D INPUT -s $1 -p tcp --dport 21 -j ACCEPT
iptables -D INPUT -s $1 -p tcp --dport 631 -j ACCEPT
iptables -D INPUT -s $1 -p tcp --dport 5125 -j ACCEPT
iptables -D INPUT -s $1 -p tcp --dport 5126 -j ACCEPT
iptables -D INPUT -s $1 -p tcp --dport 8888 -j ACCEPT
iptables -D INPUT -s $1 -p tcp --dport 10000 -j ACCEPT
iptables -D INPUT -s $1 -p tcp --dport 81 -j ACCEPT

Esempio di una connessione

Per effettuare la connessione digitare il seguente comando all’interno di una finestra di terminale: 

./knock -v <ip_host> port1 port2 port3 port...

Ora non resta altro che fare pratica e pratica ma sono sicuro che il portknocking vi dara’ tanta soddisfazione.

Leggete anche l’articolo sulla sicurezza inerente Metasploit Framework.

GreenSQL il FW per i DB

greensql-architecture
GreenSQL: un reverse proxy contro gli attacchi SQL injection

GreenSQL è un’interessante applicazione che promette di proteggere un database da eventuali attacchi dannosi. Sostanzialmente si tratta di un firewall open source che fa da filtro tra l’applicazione web e il database. Funziona come un proxy, l’applicazione invece di connettersi al database si connette a GreenSQL che poi gestisce la connessione con il database vero e proprio.

Attacchi SQL injection

Un attacco di tipo SQL injection consiste nell’inserimento “injection” di una particolare query SQL nei dati passati in input ad una applicazione da parte di un client allo scopo di provocare l’esecuzione di comandi SQL predefiniti.
Un exploit di tipo SQL injection se coronato da successo può rivelare dati sensibili da un database, modificarli, eseguire operazioni amministrative sul database (come uno shutdown od un backup), e talvolta anche impartire comandi al sistema operativo sottostante.

GreenSQL è un database firewall Open Source utilizzabile per proteggere le basi di dati da attacchi di tipo SQL injection, operando come un proxy per comandi SQL,e con integrato il supporto per Mysql.

La sua logica operativa si basa sulla valutazione dei comandi SQL, sia utilizzando una matrice di indici di rischio, sia bloccando comandi amministrativi del db (DROP, CREATE, etc).

GreenSQL opera come un reverse proxy per le connessioni Mysql. Vale a dire che invece del server Mysql, le applicazioni si connettono al server GreenSQL, che analizzerà le queries SQL e le inoltrerà al server Mysql di back-end.

Sostanzialmente funziona così: se la query mandata dall’applicazione è ritenuta rischiosa da parte di GreeSQL essa non viene mandata al DB e GreenSQL restituisce all’applicazione un risultato nullo. Alternativamente, se la query non presenta problemi, viene inviata al server e la rispostata arriva poi alla web application.

Per default GreenSQL lavora sulla porta 3305 girando tutte le richieste al server Mysql sulla porta

http://127.0.0.1:3306

Si puo’ configurare in modalita’ differenti quali :

  • Simulation Mode (database IDS): Non effettua nessuna operazione ma permette l’analisi del comportamento di GreenSQL.
  • Blocking Suspicious Commands (database IPS): In questa modalita’ effettua un analisi euristica per cercare query giudicate “illegali” e le blocca automaticamente. In questa modalita’ si richia di bloccare falsi positivi e far eseguire query che risultano essere falsi negativi.
  • Learning mode: si usa per evitare i problemi del Blocking Suspicious mode. Permette di visionare l’analisi della query e “informare” di volta in volta il software se bloccare o no questo tipo di operazioni.
  • Active protection from unknown queries (db firewall): dopo un certo periodo di “apprendimento” nella modalita’ learning mode il sistema puo’ passare alla fase successiva (bene, ho imparato tutto, ora sono pronto ad operare da solo!).

Passiamo ora all’installazione:

Si scarichi l’ultima versione del software dalla url del sito http://www.greensql.net in particolare la “GreenSQL Firewall”
riferito alla vostra piattaforma ed una volta installato il pacchetto inerente alla vostra piattaforma.

Dopo l’installazione il server greensql girera’ sulla porta 3305. provate ad accedervi con il comando:

mysql -h 127.0.0.1 -P 3305 -u root -p

Dopo aver digitato la password di root dovreste andare sul prompt di mysql (quit per uscire).

Ora il sistema e’ pronto per essere utilizzato. Non dovete far altro che avere l’accortezza di modificare i vostri script di configurazione chiedendo di connettersi sulla porta 3305 piuttosto che la 3306.

Se ad esempio il vostro CMS e’ gia’ impostato per effettuare la connessione sulla porta di default allora editate il configuration.php (o relativo file) nella sezione specifica. Ad esempio se trovate qualcosa del tipo:

$link = mysql_connect('localhost', 'mysql_user', 'mysql_password');

sostituitela con

$link = mysql_connect('localhost:3305', 'mysql_user', 'mysql_password');

Installiamo ora la greensql-console che permette di gestire, manutenere ed impostare tutte le caratteristiche di GreenSQL.

Scaricate sempre dal link per i download scaricate la “Management Console” relativa alla vostra piattaforma :

tar xvfz greensql-console-<VERSIONE> -C /opt/

cd /opt/greensql-console

vim config.php

Editate i campi:

$db_name = "greendb";

$db_user = "green";

$db_pass = "greensqlpassword";

Accertatevi di aver impostato i permessi della cartella template_c a 777:

# chmod 777 templates_c

Ora potete accedere via web alla management Console dalla URL:

http://<vostro_indirizzo_ip>/greensql-console

Da qui potete verificare tutte le operazioni che effettua il GreenSQL con le varie possibilita’ di operare.

Infine per fermare e riavviare il servizio potete eseguire i comandi:

/etc/init.d/greensql-fw stop

/etc/init.d/greensql-fw start

Buon divertimento !