script del consulente per le regole di iptables

Esiste un server senza alcuna difesa iptables :ACCEPT all..

Potrebbero esserci applicazioni personalizzate su questo server.

Se dovremmo aver bisogno di rafforzare questo server (quindi negare tutto e lasciare solo ciò che è necessario per le applicazioni) con rigide regole di iptables, dobbiamo scoprire a mano quale app utilizza quale dst/src port/protocole quindi dobbiamo scrivere le regole di iptables per loro..

La domanda : ci sono degli script che possono aiutare a raccogliere queste informazioni da una macchina in esecuzione? (dai registri?) - E generare automaticamente le regole di iptables?

Come se ci fosse l' audit2allowattivo SELinux. Solo per iptables!

La macchina non può avere interruzioni!

Es .: lo script "MAGIC" dovrebbe essere eseguito una settimana / mese sulla macchina, raccogliendo informazioni, quindi, dopo una settimana / mese, lo script sarà in grado di produrre un file di regole iptables che possiamo usare.

Molte persone potrebbero trovarsi in questa situazione (come rafforzare un server per quanto riguarda iptables). E sarebbe bello se ci fosse uno script / una soluzione in grado di fare questo: \

Fallo manualmente

sudo ss -tuanp

o

sudo netstat -tuanp

Spiegazione:

-t - show tcp sockets
-u - show udp sockets
-a - show all sockets
-n - show numeric, don't resolve 
-p - show process name

Esegui tcpdumpil computer per circa una settimana per acquisire il traffico medio. Quindi puoi esplorare il traffico usando WireShark in seguito per vedere quali porte vengono utilizzate.

Il comando per questo sarebbe tcpdump -i <interface> -s 65535 -w <some-file>

È quindi possibile mappare indietro usando netstat -tuanpper vedere quali PID / applicazioni stanno usando quali porte.

Teoricamente questo potrebbe essere scritto.

Puoi iniziare con un modello molto semplice come https://gist.github.com/jirutka/3742890 , che consente solo ssh e ping e aggiungi qualsiasi altra cosa manualmente.

un rapido script script per generare regole iptables per l'applicazione in ascolto sull'interfaccia pubblica (0.0.0.0) / tcp

netstat -lnpt | egrep '0.0.0.0:[0-9]+' | awk '{print $4,$7}' | \
sed -E -e 's/0.0.0.0://g' -e 's|[0-9]+/||' | \
awk '{printf ("iptables -A INPUT -p tcp --dport %5d --syn -m conntrack --ctstate NEW -m comment %s \n", $1,$2) }'

puoi anche usare il iptables -I INPUT <number>per iniettare le regole in una posizione specifica, con cui puoi elencareiptables -nvL --line-numbers INPUT

Sfortunatamente non esiste uno script del genere che io abbia mai visto in grado di eseguire in una modalità di apprendimento o in modalità passiva registrando tutto l'utilizzo della rete, prendendo i suoi risultati e generando un firewall effettivo utilizzando iptablesdai suoi registri.

La tua scommessa migliore sarà iniziare in modo semplice e continuare ad aggiungere continuamente i vari pezzi mentre inizi a comprendere appieno quali servizi sta fornendo il tuo sistema. Dovrai utilizzare strumenti come netstatvedere quali porte sono in uso per i vari servizi che ospiti e quali indirizzi IP vi accedono.

$ sudo netstat -tlpn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address               Foreign Address             State       PID/Program name   
tcp        0      0 0.0.0.0:25                  0.0.0.0:*                   LISTEN      26292/sendmail      
tcp        0      0 0.0.0.0:890                 0.0.0.0:*                   LISTEN      26149/ypbind        
tcp        0      0 0.0.0.0:445                 0.0.0.0:*                   LISTEN      26321/smbd          
tcp        0      0 127.0.0.1:2207              0.0.0.0:*                   LISTEN      26226/python        
tcp        0      0 127.0.0.1:2208              0.0.0.0:*                   LISTEN      26221/./hpiod       
tcp        0      0 127.0.0.1:199               0.0.0.0:*                   LISTEN      26237/snmpd         
tcp        0      0 0.0.0.0:809                 0.0.0.0:*                   LISTEN      26067/rpc.statd     
tcp        0      0 0.0.0.0:139                 0.0.0.0:*                   LISTEN      26321/smbd          
tcp        0      0 0.0.0.0:587                 0.0.0.0:*                   LISTEN      26292/sendmail      
tcp        0      0 0.0.0.0:111                 0.0.0.0:*                   LISTEN      26038/portmap       
tcp        0      0 0.0.0.0:35604               0.0.0.0:*                   LISTEN      -                   
tcp        0      0 0.0.0.0:22                  0.0.0.0:*                   LISTEN      26249/sshd          
tcp        0      0 0.0.0.0:631                 0.0.0.0:*                   LISTEN      26257/cupsd         
tcp        0      0 :::22                       :::*                        LISTEN      26249/sshd          
tcp        0      0 :::631                      :::*                        LISTEN      26257/cupsd         

NOTA: In precedenza puoi vedere quali servizi ho in esecuzione su un server che accettano connessioni TCP, ovvero "ascoltano" le connessioni su varie porte.

Iniziare con cose come SSH (porta 22) e HTTP (porta 80) è un gioco da ragazzi, se questi sono tipici del tuo sistema, quindi farei questi tipi di servizi in massa contemporaneamente. Per altri servizi come LDAP o NIS potresti volerli fare in un modo più controllato, assicurandoti che le cose non si rompano quando le introduci.

Strumenti come FireHOL , Firewall Builder (fwbuilder) ed eztables possono essere utili mentre attacchi questo progetto, poiché forniscono un buon livello di astrazione dal dover costruire iptableregole personalizzate a mano, il che può essere complicato.

FireHOL è un linguaggio (e un programma per eseguirlo) che crea firewall sicuri e con stato di qualsiasi complessità da configurazioni facili da capire e leggibili dall'uomo.

esempio

transparent_squid 8080 "squid root" inface eth0

interface eth0 mylan
    policy accept

interface ppp+ internet
    server smtp accept
    server http accept
    server ftp  accept
    server ssh  accept src example.firehol.org

    client all  accept

router mylan2internet inface eth0 outface ppp+
    masquerade
    route all accept

Fwbuilder è uno strumento grafico firewall unico che consente all'utente di creare oggetti e quindi trascinarli negli firewall, per creare un potente sistema di sicurezza per un singolo PC o una rete di PC. Fwbuilder supporta una vasta gamma di firewall (Cisco ASA / PIX, iptables Linux, filtro IP di FreeBSD, pf di OpenBSD e altro), quindi le sue regole possono essere implementate su più piattaforme. Diamo un'occhiata all'utilizzo di Fwbuilder su Linux, che potrebbe diventare un affare per tutta la vita con un potente sistema di sicurezza.

esempio

Eztables ti consente di configurare rapidamente un firewall senza mai toccare iptables. La sintassi della regola firewall è progettata per essere facile da leggere e da applicare.

Ecco come si consente a Internet intero di accedere al proprio server Web sulla porta TCP 80:

  allow_in any $eth0 any 80/tcp

Eztables è progettato per essere semplice, ma potente. Non importa se vuoi proteggere il tuo laptop, se stai configurando un router domestico o costruendo un firewall aziendale.

Utilizzando Fail2Ban

Con un iptablesfirewall rudimentale in atto, probabilmente vorrai complimentarlo utilizzando uno strumento come Fail2Ban .

Fail2ban esegue la scansione dei file di registro (ad es. / Var / log / apache / error_log) e vieta gli IP che mostrano segni dannosi: troppi errori di password, ricerca di exploit, ecc. Generalmente Fail2Ban viene quindi utilizzato per aggiornare le regole del firewall per rifiutare gli indirizzi IP per un determinato periodo di tempo, sebbene possa essere configurata anche qualsiasi altra azione arbitraria (ad esempio l'invio di un'e-mail). Fail2Ban è pronto per l'uso con filtri per vari servizi (apache, corriere, ssh, ecc.).

L'uso di strumenti come questo aiuterà a limitare l'esposizione che il tuo sistema dovrà sopportare mentre continui a rafforzarlo. Anche dopo essere abbastanza convinto che il tuo sistema sia stato rafforzato, potresti comunque voler continuare a utilizzare Fail2Ban come parte delle tue misure di sicurezza.

Riferimenti

• Crea potenti firewall Linux con Firewall Builder
• Esempio FireHOL
• Pagina principale del progetto FirewallBuilder
• Esempio base di firewall / iptables

Usa le regole di iptable per registrare le nuove connessioni, che registreranno anche udp.

iptables -I INPUT -m state --state NEW -j LOG --log-prefix "New inbound connection: "
iptables -I OUTPUT -m state --state NEW -j LOG --log-prefix "New outbound connection: "

Puoi specificare diversi --log-level per avere i log in un altro file rispetto a / var / log / messages (dovrai configurare il demone syslog).

Penso che dovresti leggere i registri dell'applicazione principali poiché alcuni server hanno un'attività molto periodica come mezzogiorno, fine settimana, fine mese (trimestre, anno), quindi non ti perderai un'importante attività di rete del server.

Poiché il server è fondamentale, rende la matrice del flusso di rete del server su un bel foglio di calcolo (sorgente ip, destinazione IP, protocollo, porta, applicazione) che ti aiuterà a costruire le regole.

So che questo non è uno script e non è una risposta alla domanda di OP, ma è una mia idea che voglio condividere con OP.

Ho ottenuto tutte le porte di ascolto con:

netstat -an | egrep 'tcp .*LISTEN' | awk -F" " '{print $4}' | awk -F":" '{print $NF}'

Forse questo può avvicinarti ancora di più alla stesura della tua sceneggiatura. :)

Puoi iniziare con qualcosa del genere:

netstat -n -l -p | egrep "^(tcp|tcp6|udp)" | grep LISTEN | sed -r 's!^(tcp|tcp6|udp)\s.*:([0-9]+).*LISTEN\s+.*/(.*)!iptables -A INPUT -p \1 --dport \2 -j ACCEPT # \3!'

e poi seguitelo con

iptables -P INPUT DROP

o

iptables -A INPUT -j REJECT --reject-with icmp-host-prohibited

Quello che fa la prima riga è usare netstat per elencare i processi di ascolto e le loro porte. Quindi genererà linee "iptables" per consentire a ciascuna di quelle connessioni in entrata. La piccola sostituzione di sed regex è stata personalizzata per l'output di netstat sul mio server, quindi potrebbe richiedere qualche modifica per te. Quando funziona, dovresti finire con qualcosa di simile:

iptables -A INPUT -p tcp --dport 111 -j ACCEPT # rpcbind       
iptables -A INPUT -p tcp --dport 22 -j ACCEPT # sshd          
iptables -A INPUT -p tcp --dport 25 -j ACCEPT # master        
iptables -A INPUT -p tcp --dport 3306 -j ACCEPT # mysqld        
iptables -A INPUT -p tcp --dport 49476 -j ACCEPT # rpc.statd     
iptables -A INPUT -p tcp --dport 5432 -j ACCEPT # postgres.bin  
iptables -A INPUT -p tcp --dport 55371 -j ACCEPT # rpc.statd

Due cose importanti da notare:

1) Queste regole non fanno nulla per te fino a quando non inserisci una riga DROP o REJECT alla fine o rendi quella la politica predefinita per i pacchetti senza eguali. Queste regole consentono i pacchetti, che è discutibile, se la politica predefinita è consentire qualsiasi cosa non abbinata.

2) Queste regole sono ambivalenti sull'IP di origine . Dal tuo post originale, sembra che tu voglia consentire a tutti i tuoi client di utilizzare il server, quindi esamina i log per ottenere gli IP di origine da utilizzare con le porte di destinazione. Non conosco uno strumento per farlo, quindi questo script impedirà solo alle persone di creare nuovi servizi sul tuo server che ascoltano su altre porte ... il che è qualcosa .