Sono sicuro che gli amministratori di sistema di Linux abbiano una certa familiarità iptables, l'interfaccia utente per il netfilterframework di filtraggio dei pacchetti.
Ora, questa "domanda" è pensata per essere un Wiki della comunità per raccogliere insieme vari pezzi di iptablessaggezza. Niente è troppo comune o troppo oscuro. Pubblica tutto quello che sai che aiuterebbe gli altri a trarre il massimo iptables.
Risposte:
#!/bin/bash
WHITELIST=/whitelist.txt
BLACKLIST=/blacklist.txt
#THIS WILL CLEAR ALL EXISTING RULES!
echo 'Clearing all rules'
iptables -F
#
## Whitelist
#
for x in `grep -v ^# $WHITELIST | awk '{print $1}'`; do
echo "Permitting $x..."
$IPTABLES -A INPUT -t filter -s $x -j ACCEPT
done
#
## Blacklist
#
for x in `grep -v ^# $BLACKLIST | awk '{print $1}'`; do
echo "Denying $x..."
$IPTABLES -A INPUT -t filter -s $x -j DROP
done
#!/bin/bash
ALLOWEDTCP="80 3128 3784"
ALLOWEDUDP="3128 3784"
#
## Permitted Ports
#
for port in $ALLOWEDTCP; do
echo "Accepting port TCP $port..."
$IPTABLES -A INPUT -t filter -p tcp --dport $port -j ACCEPT
done
for port in $ALLOWEDUDP; do
echo "Accepting port UDP $port..."
$IPTABLES -A INPUT -t filter -p udp --dport $port -j ACCEPT
done
# Attempt to block portscans
# Anyone who tried to portscan us is locked out for an entire day.
iptables -A INPUT -m recent --name portscan --rcheck --seconds 86400 -j DROP
iptables -A FORWARD -m recent --name portscan --rcheck --seconds 86400 -j DROP
# Once the day has passed, remove them from the portscan list
iptables -A INPUT -m recent --name portscan --remove
iptables -A FORWARD -m recent --name portscan --remove
# These rules add scanners to the portscan list, and log the attempt.
iptables -A INPUT -p tcp -m tcp --dport 139 -m recent --name portscan --set -j LOG --log-prefix "Portscan:"
iptables -A INPUT -p tcp -m tcp --dport 139 -m recent --name portscan --set -j DROP
iptables -A FORWARD -p tcp -m tcp --dport 139 -m recent --name portscan --set -j LOG --log-prefix "Portscan:"
iptables -A FORWARD -p tcp -m tcp --dport 139 -m recent --name portscan --set -j DROP
# Reject spoofed packets
# These adresses are mostly used for LAN's, so if these would come to a WAN-only server, drop them.
iptables -A INPUT -s 10.0.0.0/8 -j DROP
iptables -A INPUT -s 169.254.0.0/16 -j DROP
iptables -A INPUT -s 172.16.0.0/12 -j DROP
iptables -A INPUT -s 127.0.0.0/8 -j DROP
#Multicast-adresses.
iptables -A INPUT -s 224.0.0.0/4 -j DROP
iptables -A INPUT -d 224.0.0.0/4 -j DROP
iptables -A INPUT -s 240.0.0.0/5 -j DROP
iptables -A INPUT -d 240.0.0.0/5 -j DROP
iptables -A INPUT -s 0.0.0.0/8 -j DROP
iptables -A INPUT -d 0.0.0.0/8 -j DROP
iptables -A INPUT -d 239.255.255.0/24 -j DROP
iptables -A INPUT -d 255.255.255.255 -j DROP
# Drop all invalid packets
iptables -A INPUT -m state --state INVALID -j DROP
iptables -A FORWARD -m state --state INVALID -j DROP
iptables -A OUTPUT -m state --state INVALID -j DROP
# Stop smurf attacks
iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
iptables -A INPUT -p icmp -m icmp -j DROP
# Drop excessive RST packets to avoid smurf attacks
iptables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT
# Don't allow pings through
iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j DROP
iptablesriga 8, e in $IPTABLESseguito. Basta usarlo iptablesovunque? Altrimenti suppongo che avresti bisogno di assegnare qualcosa come IPTABLES=/sbin/iptablesgiusto?
ipsetSe scrivi molte regole simili basate su IP, porta o entrambi, ipsetprendi in considerazione l'utilizzo per ottimizzare le prestazioni di netfilter.
Per esempio:
iptables -s 192.168.1.11 -j ACCEPT
iptables -s 192.168.1.27 -j ACCEPT
iptables -s 192.168.1.44 -j ACCEPT
... hundreds of similar rules ...
iptables -s 192.168.251.177 -j ACCEPT
Ciò significa che un pacchetto con l'indirizzo sorgente di 192.168.251.177 deve prima attraversare centinaia di regole prima di poter ottenere il suo verdetto di ACCETTA.
Naturalmente, gli amministratori di sistema esperti suddivideranno le regole per sottorete. Ma ciò significa ancora centinaia di regole.
ipset Al salvataggio!
Innanzitutto, definire un set IP di ipmaptipo:
ipset -N Allowed_Hosts ipmap --network 192.168.0.0/16
Quindi popolarlo con gli indirizzi:
for ip in $LIST_OF_ALLOWED_IP; do ipset -A Allowed_Hosts $ip; done
Infine, sostituisci le centinaia di regole iptables sopra con una regola:
iptables -m set --match-set Allowed_Hosts src -j ACCEPT
Quando arriva un pacchetto, netfilter eseguirà una ricerca bitmap molto rapida per l'IP sorgente (src) del pacchetto rispetto al Allowed_Hostsset IP. Tutti i pacchetti provenienti da 192.168.0.0/16 subiranno una regola. E credetemi che la ricerca di una bitmap è almeno due ordini di grandezza più veloce rispetto all'esecuzione di centinaia di controlli delle regole di iptables.
ipsetnon è limitato agli indirizzi IP. Può anche corrispondere in base a porte, tupla della porta IP, indirizzi di rete / sottorete, tupla IP-MAC e così via e così via. E può corrispondere a quei criteri come sorgente o destinazione o un mix di entrambi (nel caso delle tuple).
E infine, con ipsette puoi inserire automaticamente gli indirizzi IP nelle blacklist / whitelist. Queste liste nere / liste bianche possono anche "invecchiare", eliminando così automaticamente l'indirizzo IP dopo che è trascorso un periodo di tempo configurabile.
Per ulteriori dettagli, consultare ipsetla pagina man di ".
Alcune distro Linux potrebbero non avere un supporto " ipsetpronto all'uso " per (ad esempio Ubuntu 10.04 presentava questo problema). Su questi sistemi un metodo è installare ipsetdal codice sorgente.
Invece, scarica ipsetla fonte dal suo sito Web: http://ipset.netfilter.org/install.html
In alternativa, se lo usi xtables-addons, ipset è incluso nella sua fonte: http://xtables-addons.sourceforge.net/
Aggiungi le seguenti regole, preferibilmente in -t raw -A PREROUTING
-p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
-p tcp --tcp-flags SYN,RST SYN,RST -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,PSH,URG -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN,RST,PSH,ACK,URG -j DROP
Gli attacchi da bloccare sono, rispettivamente:
(sentiti libero di modificare i nomi degli attacchi sopra)
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN,RST,PSH,ACK,URG -j DROPpotrebbe essere rimosso, come -p tcp --tcp-flags FIN,SYN FIN,SYN -j DROPsi cattura ogni pacchetto potrebbe bloccare.
echo 1 > /proc/sys/net/ipv4/ip_forward /sbin/iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADEIl passaggio 1 imposta il parametro kernel per consentire l'inoltro ip, il passaggio 2 imposta una regola iptables che abilita NAT sull'interfaccia eth0.
/etc/sysctl.conf net.ipv4.ip_forward = 1. (Supponendo Red Hat o un derivato.)
Aggiungi le seguenti regole, preferibilmente in -t raw -A PREROUTING
-p icmp -m u32 ! --u32 "4&0x3FFF=0" -j DROP
-p icmp -m length --length 1492:65535 -j DROP
La prima regola blocca tutti i pacchetti ICMP il cui "flag di frammentazione" non è 0. (ICMP non dovrebbe mai essere frammentato; dovrebbero trasportare piccoli payload)
La seconda regola blocca i pacchetti ICMP non frammentati di grandi dimensioni.
usando FireHOL - comodo wrapper iptables
L'ho trovato molto più intuitivo dei comandi diretti iptables. Soprattutto per le persone con precedenti esperienze con altri firewall:
FireHOL è un generatore di firewall iptables che produce firewall con filtraggio di pacchetti iptables con stato, su host e router Linux con qualsiasi numero di interfacce di rete, qualsiasi numero di route, qualsiasi numero di servizi serviti, qualsiasi numero di complessità tra le variazioni dei servizi (inclusi positivi e negativi espressioni).
(dal mio file iptables_tricks.txt, ricompilato da molti posti: P)
Fa aspettare iptables 15 secondi tra le nuove connessioni dallo stesso IP sulla porta 22 (SSH):
iptables -A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --update --seconds 15 -j DROP
iptables -A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --set -j ACCEPT
-A INPUT -p tcp --dport 22 -m state --state NEW -m recent --set --name SSH -A INPUT -p tcp --dport 22 -m state --state NEW -m recent --update --seconds 60 --hitcount 5 --rttl --name SSH -j DROP
Tutorial video IPTABLES
Episodio 1 http://www.youtube.com/watch?v=ldB8kDEtTZA&feature=player_embedded
Episodio 2 http://www.youtube.com/watch?v=aDaEXxRHeXY&feature=related
Episodio finale
http://www.youtube.com/watch?v=JojqHKcSxpo&feature=player_embedded
Sarà un buon inizio per qualsiasi principiante.
C'è già una risposta che menziona i set IP. Tuttavia, è piuttosto monodimensionale in quanto si concentra sui miglioramenti delle prestazioni rispetto alle regole classiche e sul fatto che i set IP mitigano il problema che si ha con un sacco di indirizzi IP individuali che non possono essere facilmente espressi come sottorete nella notazione CIDR.
Perché ipsetuserò la notazione letta ipset restoree scritta da ipset save.
In corrispondenza di iptables(e ip6tables) regole userò la notazione come letta iptables-restoree scritta da iptables-save. Questo rende una notazione più breve e mi permette di evidenziare le potenziali regole solo IPv4 (prefisso -4) o solo IPv6 (prefisso -6).
In alcuni esempi dirotteremo il flusso di pacchetti in un'altra catena. Si presume che la catena esista in quel punto, quindi le linee per creare le catene non vengono prodotte (né viene menzionato il nome della tabella o i comandi COMMITalla fine).
I set di IP possono fare molto di più di quanto menzionato nell'altra risposta e dovresti assolutamente leggere la documentazione del set di IP ( ipset(8)) insieme iptables-extensions(8)a oltre a questa breve voce qui.
Per esempio io concentrerà principalmente su tre tipi di set: hash:ip, hash:nete list:set, ma ci sono più di quelli e tutti hanno i casi d'uso valide.
Ad esempio, puoi anche abbinare i numeri di porta, non solo gli indirizzi IP .
iptables-saveeiptables-restoreÈ possibile creare dichiarazioni di set IP in blocco e importarle eseguendo il piping in ipset restore. Se si desidera rendere il comando più resiliente rispetto a voci già esistenti, utilizzare ipset -exist restore.
Se le tue regole sono in un file chiamato, default.setdovresti usare:
ipset -exist restore < default.set
Un file del genere può contenere voci per createinsiemi e addvoci in esse. Ma generalmente la maggior parte dei comandi dalla riga di comando sembra avere una versione corrispondente nei file. Esempio (creazione di un set di server DNS):
create dns4 hash:ip family inet
create dns6 hash:ip family inet6
# Google DNS servers
add dns4 8.8.8.8
add dns4 8.8.4.4
add dns6 2001:4860:4860::8888
add dns6 2001:4860:4860::8844
Qui viene creato un set per IPv4 ( dns4) e uno per IPv6 ( dns6).
I timeout nei set IP possono essere impostati come predefiniti per set e anche per voce. Ciò è molto utile per gli scenari in cui si desidera bloccare temporaneamente qualcuno (ad es. Per la scansione delle porte o il tentativo di forzare il proprio server SSH).
Il modo in cui funziona è il seguente (impostazione predefinita durante la creazione di set IP):
create ssh_loggedon4 hash:ip family inet timeout 5400
create ssh_loggedon6 hash:ip family inet6 timeout 5400
create ssh_dynblock4 hash:ip family inet timeout 1800
create ssh_dynblock6 hash:ip family inet6 timeout 1800
Torneremo su questi set particolari di seguito e sulla logica del perché sono impostati così come sono.
Se si desidera impostare il timeout per un determinato indirizzo IP, si potrebbe semplicemente dire:
add ssh_dynblock4 1.2.3.4 timeout 7200
Per bloccare IP 1.2.3.4 per due ore anziché la mezz'ora (impostata) predefinita.
Se dovessi guardarlo ipset save ssh_dynblock4dopo poco tempo, vedresti qualcosa sulla falsariga di:
create ssh_dynblock4 hash:ip family inet hashsize 1024 maxelem 65536 timeout 1800
add ssh_dynblock4 1.2.3.4 timeout 6954
Kernel error received: Unknown error -1.).sudo ipset add ssh_dynblock4 1.2.3.4 timeout $((120*60))All'interno dei tuoi script può essere utile vedere se esiste già una voce. Ciò può essere ottenuto con ipset testcui restituisce zero se la voce esiste e diversa da zero in caso contrario. Quindi i soliti controlli possono essere applicati in uno script:
if ipset test dns4 8.8.8.8; then
echo "Google DNS is in the set"
fi
Tuttavia, in molti casi preferirai utilizzare l' -existopzione a ipsetper dirigerlo a non lamentarti delle voci esistenti.
iptablesregoleQuesta, secondo me, è una delle caratteristiche killer dei set IP. Non solo puoi abbinare le voci di un set IP, ma puoi anche aggiungere nuove voci a un set IP esistente.
Ad esempio in questa risposta a questa domanda hai:
-A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --update --seconds 15 -j DROP
-A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --set -j ACCEPT
... con l'intenzione di limitare i tentativi di connessione a SSH (porta TCP 22). Il modulo utilizzato recenttiene traccia dei recenti tentativi di connessione. Invece del statemodulo, preferisco il conntrackmodulo, comunque.
# Say on your input chain of the filter table you have
-A INPUT -i eth+ -p tcp --dport ssh -j SSH
# Then inside the SSH chain you can
# 1. create an entry in the recent list on new connections
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
# 2. check whether 3 connection attempts were made within 2 minutes
# and if so add or update an entry in the ssh_dynblock4 IP set
-4 -A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock4 src --exist
-6 -A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock6 src --exist
# 3. last but not least reject the packets if the source IP is in our
# IP set
-4 -A SSH -m set --match-set ssh_dynblock4 src -j REJECT
-6 -A SSH -m set --match-set ssh_dynblock6 src -j REJECT
In questo caso sto reindirizzando il flusso verso la SSHcatena in modo che non debba ripetermi con -p tcp --dport sshogni singola regola.
Reiterare:
-m setrende iptablesconsapevole che stiamo utilizzando switch dal setmodulo (che gestisce i set IP)--match-set ssh_dynblock4 srcdice di iptablesfar corrispondere l' indirizzo source ( src) con il set ( ssh_dynblock4)
sudo ipset test ssh_dynblock4 $IP(dove $IPcontiene l'indirizzo IP di origine per il pacchetto)-j SET --add-set ssh_dynblock4 src --existaggiunge o aggiorna l' indirizzo source ( src) dal pacchetto nel set IP ssh_dynblock4. Se esiste una voce ( --exist) verrà semplicemente aggiornata.
sudo ipset -exist add ssh_dynblock4 $IP(dove $IPcontiene l'indirizzo IP di origine per il pacchetto)Se invece desideri corrispondere all'indirizzo di destinazione / destinazione, utilizzeresti dstinvece di src. Consultare il manuale per ulteriori opzioni.
I set IP possono contenere altri set. Ora, se hai seguito l'articolo fino a qui, ti starai chiedendo se è possibile combinare set. E ovviamente lo è. Per i set IP dall'alto possiamo creare due set di giunti ssh_dynblocke ssh_loggedonrispettivamente per contenere solo i set solo IPv4 e solo IPv6:
create ssh_loggedon4 hash:ip family inet timeout 5400
create ssh_loggedon6 hash:ip family inet6 timeout 5400
create ssh_dynblock4 hash:ip family inet timeout 1800
create ssh_dynblock6 hash:ip family inet6 timeout 1800
# Sets of sets
create ssh_loggedon list:set
create ssh_dynblock list:set
# Populate the sets of sets
add ssh_loggedon ssh_loggedon4
add ssh_loggedon ssh_loggedon6
add ssh_dynblock ssh_dynblock4
add ssh_dynblock ssh_dynblock6
E la domanda successiva che dovrebbe sorgere nella tua mente è se questo ci consente di abbinare e manipolare i set IP in modo indipendente dalla versione IP.
E la risposta a ciò è clamorosa: SÌ! (ahimè, questo non è stato documentato esplicitamente l'ultima volta che ho controllato)
Di conseguenza, le regole della sezione precedente possono essere riscritte per leggere:
-A INPUT -i eth+ -p tcp --dport ssh -j SSH
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
-A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock src --exist
-A SSH -m set --match-set ssh_dynblock src -j REJECT
che è molto più conciso. E sì, questo è provato e testato e funziona come un fascino.
Sui miei server ho uno script eseguito come cronlavoro che prende un sacco di nomi host e li risolve in indirizzi IP, quindi inserendolo nel set IP per "host fidati". L'idea è che gli host fidati facciano più tentativi di accedere al server e non sono necessariamente bloccati per tutto il tempo.
Al contrario, ho interi paesi bloccati dalla connessione al mio server SSH, con la (potenziale) eccezione di host fidati (cioè l'ordine delle regole è importante).
Tuttavia, questo è lasciato come esercizio per il lettore. Qui vorrei aggiungere una soluzione ordinata che utilizzerà i set contenuti nel ssh_loggedonset per consentire il passaggio dei successivi tentativi di connessione e non essere soggetti allo stesso controllo degli altri pacchetti.
È importante ricordare i timeout predefiniti di 90 minuti ssh_loggedone 30 minuti ssh_dynblockquando si osservano le seguenti iptablesregole:
-A INPUT -i eth+ -p tcp --dport ssh -j SSH
-A SSH -m set --match-set ssh_loggedon src -j ACCEPT
-A SSH -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
-A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock src --exist
-A SSH -m set --match-set ssh_dynblock src -j REJECT
Ormai dovresti chiederti come finisce l'indirizzo IP di connessione nei ssh_loggedonsottoinsiemi. Quindi continua a leggere ...
Se hai sperimentato sshrce amici, avrai appreso delle sue carenze. Ma PAM viene in soccorso. Un modulo chiamato pam_exec.soci consente di invocare uno script durante l'accesso SSH in un punto in cui sappiamo che l'utente è ammesso.
In /etc/pam.d/sshdsotto le voci pam_enve pam_selinuxaggiungere la seguente riga:
session optional pam_exec.so stdout /path/to/your/script
e assicurati che la tua versione dello script ( /path/to/your/scriptsopra) esista e sia eseguibile.
PAM utilizza le variabili di ambiente per comunicare cosa sta succedendo, quindi puoi usare un semplice script come questo:
#!/bin/bash
# When called via pam_exec.so ...
SETNAME=ssh_loggedon
if [[ "$PAM_TYPE" == "open_session" ]] && [[ -n "$PAM_RHOST" ]]; then
[[ "x$PAM_RHOST" != "x${PAM_RHOST//:/}" ]] && SETNAME="${SETNAME}6" || SETNAME="${SETNAME}4"
ipset -exist add $SETNAME "$PAM_RHOST"
fi
Sfortunatamente l' ipsetutilità non sembra avere gli smart built-in di netfilter. Quindi dobbiamo distinguere tra IPv4 e IPv6 IP set quando aggiungiamo la nostra voce. Altrimenti ipsetsupponiamo che vogliamo aggiungere un altro set al set di set, anziché IP. E ovviamente è improbabile che ci sia un set che prende il nome da un IP :)
Quindi controlliamo :l'indirizzo IP e 6in questo caso aggiungiamo il nome impostato 4.
La fine.
Un'altra GUI che può essere utilizzata per configurare iptables è Firewall Builder . Consente agli utenti di creare elementi delle regole come oggetti in un database e quindi trascinarli e rilasciarli in un editor di regole per creare il criterio firewall desiderato. L'applicazione quindi genera un file di script con tutti i comandi iptables richiesti per implementare le regole.
A differenza di altre soluzioni GUI di iptables in cui è possibile gestire solo una configurazione di iptables alla volta, con Firewall Builder è possibile gestire un gran numero di configurazioni di iptables tutte da un'unica applicazione. Firewall Builder funziona su Linux, Windows e Mac OS X, esiste da oltre 10 anni e ha migliaia di utenti attivi in tutto il mondo.
Full Disclosure - Sono il co-fondatore di NetCitadel, la società che sviluppa Firewall Builder.
registra la connessione in uscita con uid
iptables -A OUTPUT -m state --state NEW -m tcp -p tcp -m limit --limit 5/m -j LOG --log-uid --log-prefix="outgoing connection: "
port / forwarding di connessione:
iptables -A PREROUTING -t nat -i eth1 -p tcp --dport 80 -j DNAT --to 10.0.1.7:80
iptables -A INPUT -p tcp -m state --state NEW --dport 80 -i eth1 -j ACCEPT
NFLOGbersaglio. Consente un prefisso di linea più lungo e il demone in modalità utente può accedere anche ai database.
Esempio: hai eth0 e vuoi eth1consentire il traffico tra di loro?
iptables -A FORWARD -i eth+ -o eth+ -j ACCEPT
L'ho usato in passato per abbinare le veth<something>interfacce create dinamicamente e denominate da LXC. Quindi posso abbinare tutto in una volta con veth+.
Ho anche chiamato intenzionalmente alcune interfacce _<something>per abbinarle _+.
iptables -t mangle -A PREROUTING -p tcp \
-m conntrack --ctstate NEW -m tcpmss ! --mss 536:65535 -j DROP
Lo scopo di questa destinazione è verificare se l'host che ha inviato il pacchetto SYN stabilisce la connessione o non fa nulla dopo aver avviato la connessione SYN. Se non fa nulla, scarta il pacchetto con il minimo sforzo.
Impostare i pacchetti syn sulla tabella di tracciamento delle connessioni nella tabella non elaborata
iptables -t raw -A PREROUTING -p tcp -m tcp --dport 80 --syn -j CT --notrack
Abilita synproxy per il server http:
iptables -A INPUT -p tcp -m tcp --dport 80 -m conntrack --ctstate INVALID,UNTRACKED \
-j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460
Risorsa: target SYNPROXY dal blog RHEL
Limitazione di tutti i singoli indirizzi IP a una quota di larghezza di banda in uscita con set IP
Potresti configurare il tuo server in modo che consenta a ogni singolo IP 15GiByte di utilizzo della larghezza di banda al mese, nella speranza di riflettere o schivare un attacco di utilizzo della larghezza di banda, forse per la tua quota di larghezza di banda misurata sul tuo ISP. Può essere realizzato come segue:
Innanzitutto creare i set IP per IPv4 e IPv6:
ipset create IP_QUOTA_SET_OUT hash:ip timeout 345600 counters
ipset create IP_QUOTA_SET_OUT_INET6 hash:ip timeout 345600 counters family inet6
Ora aggiungi le tue regole iptables. La prima riga aggiungerà l'IP al set se non è già presente. La seconda riga non corrisponderà se i byte trasferiti per l'IP nell'insieme sono superiori all'importo specificato. Quindi lo stesso vale per IPv6.
iptables -I OUTPUT -m set ! --match-set IP_QUOTA_SET_OUT dst -j SET --add-set IP_QUOTA_SET_OUT dst --timeout 345600
iptables -I OUTPUT -m set --match-set IP_QUOTA_SET_OUT dst --bytes-gt 16106127360 -j DROP
ip6tables -I OUTPUT -m set ! --match-set IP_QUOTA_SET_OUT_INET6 src -j SET --add-set IP_QUOTA_SET_OUT_INET6 src --timeout 345600
ip6tables -I OUTPUT -m set --match-set IP_QUOTA_SET_OUT_INET6 src --bytes-gt 16106127360 -j DROP
Questo eviterà attacchi come un utente che richiede un file di grandi dimensioni dal tuo server web per un lungo periodo di tempo o da qualsiasi servizio per quella materia. Lo stesso può essere fatto per la catena INPUT.
Qualcosa che faccio, principalmente a causa della mia ignoranza di una soluzione più elegante, è controllare manualmente i miei registri Nginx ogni 4 ore e il registro del server di posta ogni 2 minuti per un accesso eccessivo da parte dei singoli IP. Corro insieme alcuni script che:
access.loged elenca i 10 principali IP organizzati in base al numero di hit che hanno sul serveriptables.saveEcco come appare:
autoBanIPs_mail.sh#!/bin/bash
# This script checks the last 2 minutes of log entries to see if any
# IP has made over 99 connections
now=$(date +"%m_%d_%Y")
/root/bin/checkBadIPs_mail.sh > /home/ipChecker/ipcheckMAIL_$now.txt
cat /home/ipChecker/ipcheckMAIL_$now.txt | \
grep " \\(\\([9][9]\\)\\|\\([0-9][0-9][0-9]\\+\\)\\) " | \
awk '{print $2}' > /home/ipChecker/badMailIPs_$now.sh
sed -i "s/^/\/usr\/local\/sbin\/blockIP /g" /home/ipChecker/badMailIPs_$now.sh
/bin/bash /home/ipChecker/badMailIPs_$now.sh
cat /home/ipChecker/ipcheckMAIL_$now.txt >> /home/ipChecker/ipcheckMAIL_$now.log
rm /home/ipChecker/ipcheckMAIL_$now.txt
rm /home/ipChecker/badMailIPs_$now.sh
Una cosa che è MOLTO importante da notare qui è che DEVI impostare una whitelist o inizierai a bloccare un sacco di IP autentici dai server che ricevi solo molta e-mail da o nel caso di altri registri, IP che colpisci molto il tuo server per motivi legittimi. La mia whitelist è appena integrata in questo script aggiungendo le pipe grep subito dopo | grep ']' | che assomigliano a questo "grep -v 127.0 |" .
Devi prendere il tempo necessario per insegnare al tuo server quali IP ad alto traffico sono legittimi e quali no. Per me questo significava che dovevo passare la prima settimana circa a controllare manualmente i miei registri ogni due ore, cercando gli IP ad alto traffico su iplocation.net e quindi aggiungendo quelli legittimi come Amazon, Box.com o anche la mia casa / ufficio Gli IP vanno a questa lista bianca. In caso contrario verrai probabilmente bloccato dal tuo server o inizierai a bloccare server di posta / web legittimi e causerai interruzioni nella posta elettronica o nel traffico.
cat /var/log/mail.log | awk \
-v d1="$(date --date="-2 min" "+%b %_d %H:%M")" \
-v d2="$(date "+%b %_d %H:%M")" \
'$0 > d1 && $0 < d2 || $0 ~ d2' | \
grep '\[' | grep '\]' | \
grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -v 127.0 | \
awk '{print $1}' | sort | uniq -c | sort -n | tail -10
#!/bin/bash
sudo iptables -I INPUT -s $1 -j DROP
sudo bash -c "iptables-save > /etc/network/iptables.save"
Ancora una volta so che questo è rozzo da morire e c'è probabilmente un protocollo pulito ed efficiente che fa tutto questo ma non lo sapevo e questa cosa è andata avanti per un anno o due ora e tenendo a bada i cattivi. L'unica cosa che raccomanderei molto seriamente è che hai un proxy o un altro server dietro le quinte che puoi usare per accedere al tuo server principale .. Il motivo è che se stai facendo lo sviluppo web un giorno di punto in bianco e tu esegui il ping di te stesso 2000 volte in 5 ore per alcuni test che potresti essere bloccato senza alcun ritorno, tranne che per un proxy.
Puoi vedere che in checkBadIPs.shho messo grep -v 127.0 e nei miei file effettivi ho un sacco di regole da ignorare per il mio IP e altri intervalli di IP fidati, ma a volte il tuo IP cambia, ti dimentichi di aggiornare e poi sei bloccato dal tuo server.
Spero comunque che aiuti.
Ho cambiato un po 'le cose in modo che ora invece di controllare ogni due ore ho alcuni registri controllati ogni 2 minuti, principalmente il mio registro di autenticazione SSH e il registro di posta mentre venivano martellati :(.
Ho impostato script specifici per ogni file di registro, anche se sarebbe abbastanza facile dallo script manuale che uso me stesso quando voglio ispezionare i registri. Somiglia a questo:
#!/bin/bash
log=$1 time=$2
cat /var/log/${log} | awk \
-v d1="$(date --date="-${time} min" "+%b %_d %H:%M")" \
-v d2="$(date "+%b %_d %H:%M")" \
'$0 > d1 && $0 < d2 || $0 ~ d2' | \
grep '\[' | grep '\]' | \
grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | \
sort | uniq -c | sort -n | tail -10
Ciò richiede 2 input durante l'esecuzione, il file di registro che si desidera scansionare e quanto indietro nel passato si desidera scansionare.
Quindi, se volessi controllare mail.log per i conteggi IP, diciamo 75 minuti nel passato, avrei eseguito:
$ sudo script.sh mail.log 75
ipsetpiuttosto che allungare la catena iptables, ma l'idea è fantastica e penso che li applicherò ai miei server di produzione. Grazie per la condivisione!
Sono d'accordo con i commenti su ipset e flag tcp, ma manca ancora molto:
Usa xtables-addons geoip match invece di ipset per gli elenchi di paesi. Aggiorna i dati di geoip regolarmente (almeno una volta al mese). I dati sono più dinamici di un elenco ipset "ignora e dimentica".
Prendi in considerazione il monitoraggio dello stato della connessione con flag tcp. Ad esempio, un TCST RST o ACK ha senso solo per una connessione stabilita. SYN ha senso solo per le connessioni nuove e correlate. Un SYN per una connessione stabilita significa che il tuo SYN + ACK è stato perso o un tentativo di hacking e deve essere ripristinato poiché entrambi i lati della connessione non concordano sullo stato.
Sebbene nessuno, SYN + RST e FIN + RST siano combinazioni illegali, SYN + FIN è valido ora con TCP Fast-Open (opzione TCP 34), in particolare per DNS. I pacchetti SYN, anche con apertura rapida, non devono essere frammentati. Non considero utili le regole con le bandiere PSH e URG. Non confondere lo stato di tracciamento della connessione con lo stato TCP: una risposta RST a un pacchetto SYN viene stabilita a scopo di tracciamento.
SYNPROXY è per i pacchetti inoltrati e non aggiunge nulla per quelli consegnati localmente oltre al supporto di syncookie.
I pacchetti di errori ICMP saranno sempre nello stato correlato e della lunghezza 48: 576 se sono validi. Lunghezza 84: 1280 per IPv6. Tutti gli altri dovrebbero essere ignorati. Poiché la loro dimensione massima è anche l'MTU minimo, non dovrebbero mai essere frammentati. Le richieste ICMP (ping, timestamp, ecc.) Saranno sempre nuove e le risposte stabilite. Rilasciare i pacchetti ICMP in altri stati.
Come nell'esempio SSH con un elenco recente e che accetta solo i pacchetti SYN successivi, lo stesso dovrebbe essere fatto per SMTP ed è simile al "greylisting" sul solo riferimento dell'indirizzo IP.
Nella tabella dei filtri, la prima (o la seconda, se si accettano prima i pacchetti di stato stabiliti) nelle catene di input e output dovrebbe accettare tutto sull'interfaccia di loopback. Dovresti fidarti dei tuoi pacchetti interni. Se non ci riesci, hai problemi maggiori oltre a una soluzione firewall.
Infine, non copiare alla cieca le regole a meno che tu non capisca veramente cosa fanno. Così tante liste di regole simili lo fanno, e il più delle volte il risultato è ridicolo.
#!/bin/bash
# The following iptables/ip6tables configurations have
# been kindly shared with us from ArckWiki. There are
# a few additions apart from what has been defined.
#
#=================Flush current definitions==============
iptables -F
ip6tables -F
iptables -X
ip6tables -X
#
#=================Chains=================================
#
#----Define chains for opened ports
iptables -N TCP
ip6tables -N TCP
iptables -N UDP
ip6tables -N UDP
#
#----Setting up the filter table for NAT
# iptables -N fw-interfaces
# ip6tables -N fw-interfaces
# iptables -N fw-open
# ip6tables -N fw-open
#
#================Default Chain reactions=================
#
#----Default FORWARD reaction
iptables -P FORWARD DROP
ip6tables -P FORWARD DROP
#
#----Default OUTPUT reaction
iptables -P OUTPUT ACCEPT
ip6tables -P OUTPUT ACCEPT
#
#----Shellshock
iptables -A INPUT -m string --algo bm --hex-string '|28 29 20 7B|' -j DROP
ip6tables -A INPUT -m string --algo bm --hex-string '|28 29 20 7B|' -j DROP
#
#----Default INPUT reaction
iptables -P INPUT DROP
ip6tables -P INPUT DROP
#
#----Drop spoofing packets
iptables -A INPUT -i eth0 -s 127.0.0.0/8 -j DROP
iptables -A INPUT -i wlan0 -s 127.0.0.0/8 -j DROP
iptables -A INPUT -i wlan1 -s 127.0.0.0/8 -j DROP
iptables -A INPUT -s 10.0.0.0/8 -j DROP
iptables -A INPUT -s 169.254.0.0/16 -j DROP
iptables -A INPUT -s 172.16.0.0/12 -j DROP
iptables -A INPUT -s 224.0.0.0/4 -j DROP
iptables -A INPUT -d 224.0.0.0/4 -j DROP
iptables -A INPUT -s 240.0.0.0/5 -j DROP
iptables -A INPUT -d 240.0.0.0/5 -j DROP
iptables -A INPUT -s 0.0.0.0/8 -j DROP
iptables -A INPUT -d 0.0.0.0/8 -j DROP
iptables -A INPUT -d 239.255.255.0/24 -j DROP
iptables -A INPUT -d 255.255.255.255 -j DROP
#
#================Ping rate limiting globally=============
iptables -A INPUT -p icmp --icmp-type 8 -m limit --limit 30/min --limit-burst 8 -j ACCEPT
ip6tables -A INPUT -p icmpv6 --icmpv6-type 8 --match limit --limit-burst 8 -j ACCEPT
iptables -A INPUT -p icmp --icmp-type 8 -j DROP
ip6tables -A INPUT -p icmpv6 --icmpv6-type 8 -j DROP
#
#----flooding RST packets, smurf attack Rejection
iptables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT
ip6tables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT
#
#----Bogus packet DROP
iptables -A INPUT -p tcp -m tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
ip6tables -A INPUT -p tcp -m tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
iptables -A INPUT -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j DROP
ip6tables -A INPUT -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j DROP
#
#================RELATED,ESTABLISHED reaction============
iptables -A INPUT --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
ip6tables -A INPUT --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
#
#================unfetered loopback======================
iptables -A INPUT -i lo -j ACCEPT
ip6tables -A INPUT -i lo -j ACCEPT
#
#================INVALID catagory of packets=============
iptables -A INPUT -p 41 -j ACCEPT
iptables -A INPUT --match conntrack --ctstate INVALID -j DROP
ip6tables -A INPUT --match conntrack --ctstate INVALID -j DROP
#
#================IPv6 reactions and definitions==========
ip6tables -A INPUT -s fe80::/10 -p icmpv6 -j ACCEPT
ip6tables -t raw -A PREROUTING -p icmpv6 -s fe80::/10 -j ACCEPT
ip6tables -t raw -A PREROUTING --match rpfilter -j ACCEPT
ip6tables -t raw -A PREROUTING -j DROP
#
#=======Acceptable INVALIDs and a curteous response======
iptables -A INPUT -p udp --match conntrack --ctstate NEW -j UDP
ip6tables -A INPUT -p udp --match conntrack --ctstate NEW -j UDP
iptables -A INPUT -p tcp --syn --match conntrack --ctstate NEW -j TCP
ip6tables -A INPUT -p tcp --syn --match conntrack --ctstate NEW -j TCP
#
#================Defining the TCP and UDP chains
#
#########################################################
# Notes for port open definitions #
# It is important to note that this should be config- #
# ured differently if you're providing any routing #
# activity for any purpose. it is up to you to actively #
# define what suites your needs to get the job done. #
# In this example, I'm exempting IPv6 from being able #
# to interact with SSH protocols for two reasons. The #
# first is because it is generally easier and more com- #
# for internal networks to be deployed with IPv4. The #
# second reason is, IPv6 can be deployed globally. #
#########################################################
#
#----SSH configured for eth0
iptables -A TCP -i eth0 -p tcp --dport ssh -j ACCEPT
#!---Blocking SSH interactions in IPv6
ip6tables -A TCP -p tcp --dport ssh -j DROP
#!---Leave commented for end service device
# iptables -A TCP -p tcp --dport 80 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 80 -j ACCEPT
# iptables -A TCP -p tcp --dport 443 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 443 -j ACCEPT
#
#!---Uncomment for remote service to this device
# iptables -A TCP -p tcp --dport 22 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 22 -j ACCEPT
#
#!---Uncomment if you're providing routing services
# iptables -A UDP -p udp 53 -j ACCEPT
# ip6tables -A UDP -p udp 53 -j ACCEPT
#
#=================Tricking port scanners=================
#
#----SYN scans
iptables -I TCP -p tcp --match recent --update --seconds 60 --name TCP-PORTSCAN -j DROP
ip6tables -I TCP -p tcp --match recent --update --seconds 60 --name TCP-PORTSCAN -j DROP
iptables -A INPUT -p tcp --match recent --set --name TCP-PORTSCAN -j DROP
ip6tables -A INPUT -p tcp --match recent --set --name TCP-PORTSCAN -j DROP
#
#----UDP scans
iptables -I UDP -p udp --match recent --update --seconds 60 --name UDP-PORTSCAN -j DROP
ip6tables -I UDP -p udp --match recent --update --seconds 60 --name UDP-PORTSCAN -j DROP
iptables -A INPUT -p udp --match recent --set --name UDP-PORTSCAN -j DROP
ip6tables -A INPUT -p udp --match recent --set --name UDP-PORTSCAN -j DROP
#
#----For SMURF attack protection
iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
iptables -A INPUT -p icmp -m limit --limit 2/second --limit-burst 2 -j ACCEPT
ip6tables -A INPUT -p icmpv6 -m limit --limit 2/second --limit-burst 2 -j ACCEPT
#
#----Ending all other undefined connections
iptables -A INPUT -j DROP
ip6tables -A INPUT -j DROP
#
#=======Defining the IN_SSH chain for bruteforce of SSH==
#
#!---I've elected to keep IPv6 out of this realm for
#!---ease of use
iptables -N IN_SSH
iptables -A INPUT -p tcp --dport ssh --match conntrack --ctstate NEW -j IN_SSH
iptables -A IN_SSH --match recent --name sshbf --rttl --rcheck --hitcount 3 --seconds 10 -j DROP
iptables -A IN_SSH --match recent --name sshbf --rttl --rcheck --hitcount 4 --seconds 1800 -j DROP
iptables -A IN_SSH --match recent --name sshbf --set -j ACCEPT
iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -j IN_SSH
#
#==================Setting up a NAT gateway==============
#
#########################################################
# #
# I commented this half out because it's not something #
# that will apply to all setups. Make note of all par- #
# tinate interfaces and what exactly is going on. #
# #
#########################################################
#
#----Setting up the FORWARD chain
# iptables -A FORWARD --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
# ip6tables -A FORWARD --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
#
#
#----Defining the fw-interfaces/open chains for FORWARD
# iptables -A FORWARD -j fw-interfaces
# ip6tables -A FORWARD -j fw-interfaces
# iptables -A FORWARD -j fw-open
# ip6tables -A FORWARD -j fw-open
# iptables -A FORWARD -j DROP # Should be REJECT. But, fuck them
# ip6tables -A FORWARD -j DROP
# iptables -P FORWARD DROP
# ip6tables -P FORWARD DROP
#
#
#----Setting up the nat table
# iptables -A fw-interfaces -i ### -j ACCEPT
# ip6tables -A fw-interfaces -i ### -j ACCEPT
# iptables -t nat -A POSTROUTING -s w.x.y.z/S -o ppp0 -j MASQUERADE
# ip6tables -t nat -A POSTROUTING -s fe::/10 -o ppp0 -j MASQUERADE
#----The above lines should be repeated specifically for EACH interface
#
#----Setting up the PREROUTING chain
#
#######################################################
# #
# The PREROUTING chain will redirect either port #
# targets to be redirected. This can also redirect #
# traffic inbound to your network from the gateway #
# to this machine. This can be useful if you're using #
# a honeypot or have any service within your network #
# that you want to be pointed to a specific device. #
# #
#######################################################
#
#----SSH honeypot server
# iptables -A fw-open -d HONEYPOT_IP -p tcp --dport 22 -j ACCEPT
# ip6tables -A fw-open -d HONEYPOT_IP -p tcp --dport 22 -j ACCEPT
#----With intuition, you can configure the above to also direct specific
#----requests to other devices providing those services. The bellow will
#----be for a squid server
# iptables -A fw-open -d SQUID_IP -p tcp --dport 80 -j ACCEPT
# ip6tables -A fw-open -d SQUID_IP -p tcp --dport 80 -j ACCEPT
# iptables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to SQUID_IP
# ip6tables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to SQUID_IP
#
#===============Declare configurations=================
iptables -nvL
ip6tables -nvL