18 controlli automatici: policy, loopback, conntrack, SSH, ICMP, anti-spoofing, logging, porte pericolose, SYN flood, port scan e altro. Score 0-100 con raccomandazioni.
Rileva regole oscurate (shadowed), irraggiungibili, duplicate, contraddittorie e problemi di ordinamento.
Visualizza il flusso dei pacchetti attraverso le catene reali del tuo ruleset: quante regole per catena, policy, target usati, salti a catene utente.
Incolla un ruleset iptables-save o nft list ruleset e convertilo nell'altro formato.
Confronta due configurazioni iptables-save per trovare le differenze.
Simula il percorso di un pacchetto attraverso le regole del firewall.
Configurazioni pronte all'uso per scenari comuni. Disponibili in formato iptables e nftables.
Scansiona un target prima e dopo aver applicato le regole firewall per verificare che funzionino correttamente.
Analisi completa di un target con score globale A-F. Seleziona i moduli da eseguire.
Proprietario dominio, registrar, date creazione/scadenza, name servers, DNSSEC, ASN (per IP).
Risoluzione inversa da IP a hostname (record PTR). Inserisci uno o più IP, uno per riga.
Query multi-resolver con confronto propagazione. 16 tipi di record, 7 resolver (5 standard + 2 con filtro sicurezza/famiglia) + custom.
Rileva Web Application Firewall e CDN: Cloudflare, AWS WAF, Akamai, Sucuri, Imperva, ModSecurity, Fastly e altri.
Cookie security, CORS misconfiguration, HTTP methods pericolosi. Audit completo o singoli check.
Rileva tecnologie web: server, linguaggio, CMS, framework JS, analytics, CDN, e-commerce, font.
Verifica conformita' GDPR, PCI DSS, OWASP: cookie consent, TLS, security headers, DNSSEC, security.txt.
Analizza robots.txt e sitemap.xml: regole di accesso, path nascosti, URL indicizzati.
Analisi Content Security Policy: rileva unsafe-inline, unsafe-eval, wildcard, direttive mancanti. Spiegazioni e fix per ogni problema.
Analisi completa protocolli, cipher suite, catena certificati, vulnerabilita', grading A-F.
Rileva web server, CMS, path sensibili, CVE note, suggerimenti hardening.
Scansiona le porte di un host. Mostra servizi aperti, chiusi e filtrati. Non richiede nmap.
IP pubblico v4/v6, PTR reverse, ASN, ISP, localita'. Rileva la tua identita' in rete o analizza un IP.
SPF, DKIM, DMARC, server MX, blacklist RBL, STARTTLS. Verifica la sicurezza della posta del dominio.
Localizza IP e hostname: coordinate, paese, citta', ISP, ASN, timezone. Rileva proxy, VPN, hosting e connessioni mobile. Supporta lookup singolo, bulk e calcolo distanza.
Scopri sottodomini di un dominio usando due metodi: dizionario DNS (500 prefissi comuni, istantaneo) e Certificate Transparency Logs tramite crt.sh (quando disponibile). Rileva sottodomini sospetti (staging, admin, dev), IP privati esposti e certificati scaduti.
Scansiona host da file zona DNS o lista manuale. Analisi DNS, SSL, fingerprint in tempo reale.
Trascina qui il file zona DNS
Formato BIND (da named, PowerDNS export, dig axfr). Oppure clicca per selezionare.
Testa parametri di redirect comuni per verificare se il sito permette redirect aperti verso domini esterni.
?redirect=) e reindirizza l'utente verso qualsiasi indirizzo esterno senza validazione.https://tuosito.com/login?next=https://phishing.com — la vittima vede il tuo dominio, si fida, clicca e finisce su un sito di phishing che imita la pagina di login./pagina) o una whitelist di domini autorizzati.
Verifica se il sito e' protetto dal clickjacking (X-Frame-Options, CSP frame-ancestors).
X-Frame-Options: DENY e Content-Security-Policy: frame-ancestors 'none'. Se il sito deve essere in iframe dello stesso dominio, usare SAMEORIGIN e frame-ancestors 'self'.
Decodifica, valida catena, genera CSR, converti formati.
Incolla gli header di un'email per tracciare il percorso e verificare SPF/DKIM/DMARC.
Genera hash da testo o identifica un hash sconosciuto.
Codifica e decodifica: Base64, URL, HTML entities, Hex, ROT13.
Decodifica JWT (3 parti, payload in chiaro) e JWE (5 parti, payload cifrato). Per JWE inserisci la chiave per decifrare.
Converti tra Unix epoch e data leggibile. Supporta secondi, millisecondi, ISO 8601.
Audit configurazioni sshd_config e generatore chiavi SSH.
Audit configurazioni OpenVPN e WireGuard. Generatore WireGuard con chiavi e config pronte.
Genera configurazione BIND9 completa con RPZ (DNS filtering), DDNS per client VPN e logging strutturato. Alberatura Debian. Funziona con OpenVPN e WireGuard.
sudo dpkg -i netforge-ovpn-reports_1.0_all.deb — Info: ovpn.netforge.it
setup-bind.sh va usato solo su prima installazione.
Genera configurazione SSL/TLS ottimizzata per il tuo web server basata sulle linee guida Mozilla. Scarica il file pronto all'uso.
Genera profili AppArmor per servizi Linux. Seleziona un preset o configura manualmente capabilities, path e regole di rete. Il profilo generato va copiato su /etc/apparmor.d/ del server target.
complain prima di passare a enforce. Un profilo errato puo' bloccare il servizio.
r=leggi w=scrivi rw=lettura+scrittura rax=esegui ix=eredita profilo ux=esegui non confinato
deny network — nessun accesso di reteScansione completa della rete locale in un click: host attivi, porte, DHCP, identita' esterna, velocita' e topologia. Richiede accesso alla rete locale (no VPN).
Audit sicurezza dispositivi IoT: telecamere IP, DVR/NVR, smart home, sensori, stampanti di rete. Verifica porte, RTSP, credenziali default, UPnP.
Cattura e analisi pacchetti di rete in tempo reale. Rilevamento automatico di ARP Poisoning, DHCP Rogue, DNS Spoofing, SYN Flood e Port Scan.
sudo per catturare pacchetti.host 192.168.0.1 — tutto il traffico da/verso un IPsrc host 192.168.0.50 — solo traffico in uscita da un IPdst host 10.0.0.1 — solo traffico verso un IPport 80 — traffico HTTPport 443 — traffico HTTPSportrange 8000-8100 — range di portetcp — solo TCPudp — solo UDPicmp — solo ping/ICMParp — solo ARPhost 192.168.0.50 and port 80 — HTTP di un hosttcp and not port 443 — TCP escluso HTTPSsrc net 192.168.0.0/24 — traffico dalla subnet localearp or icmp — ARP e ping insiemedst host 192.168.0.1 and tcp port 53 — query DNS verso il gateway
Connessioni uscenti per processo con geolocalizzazione. Rivela quali processi del sistema comunicano con l'esterno e verso dove.
Scansiona la rete: host attivi, porte aperte, MAC address con riconoscimento vendor/marca. Lascia il campo subnet vuoto per rilevare automaticamente la rete locale, oppure inserisci una subnet CIDR (es. 10.10.5.0/24) per scansionare reti remote.
Su subnet remote: MAC address e vendor non disponibili (ARP non attraversa il router), mDNS assente, rilevamento ARP spoofing disabilitato. Ping sweep e port scan funzionano su qualsiasi subnet raggiungibile.
Rileva proxy aperti (SOCKS4/5, HTTP), nodi di uscita Tor. Scansiona singolo host o intera rete locale.
Scansiona tutte le macchine della rete locale cercando porte proxy aperte e nodi Tor. Usa nmap se disponibile.
Traccia il percorso di rete verso qualsiasi host. Mostra ogni hop con latenza, ASN/ISP, paese e rilevamento IP privati.
Misura throughput reale tra due endpoint. Compatibile con pfSense, OPNsense, Linux, Windows, macOS.
Rileva server DHCP sulla rete locale. Utile per trovare DHCP rogue, verificare relay e controllare i parametri offerti (lease, gateway, DNS).
Misura velocita' di download, latenza e jitter della tua connessione Internet. Scarica file di test pubblici da 10 endpoint distribuiti su 4 continenti (OVH, Hetzner, CacheFly). NetForge sceglie automaticamente l'endpoint piu' vicino in base alla tua posizione geografica via GeoLite2 locale.
Ping ICMP e probe TCP/UDP su singola porta. Come telnet/netcat ma dal browser.
Genera password sicure, analizza la forza di una password esistente, e crea file htpasswd per Apache/Nginx.
Netfilter e' il framework del kernel Linux che gestisce il filtraggio dei pacchetti. iptables e' l'interfaccia userspace per configurarlo.
| Tabella | Scopo | Catene | Uso tipico |
|---|---|---|---|
filter |
Filtraggio pacchetti (default) | INPUT, FORWARD, OUTPUT | ACCEPT, DROP, REJECT |
nat |
Network Address Translation | PREROUTING, INPUT, OUTPUT, POSTROUTING | SNAT, DNAT, MASQUERADE, REDIRECT |
mangle |
Modifica header pacchetti | Tutte e 5 | MARK, TOS, TTL, TCPMSS |
raw |
Eccezioni al connection tracking | PREROUTING, OUTPUT | NOTRACK, CT |
security |
Regole MAC (SELinux) | INPUT, FORWARD, OUTPUT | SECMARK |
nat. SNAT solo in POSTROUTING, DNAT solo in PREROUTING/OUTPUT.
L'ordine delle regole e' fondamentale. Le regole vengono valutate dall'alto verso il basso, e la prima corrispondenza vince.
loconntrack --ctstate ESTABLISHED,RELATED# 1. Loopback iptables -A INPUT -i lo -j ACCEPT # 2. Connessioni stabilite (PRIMA di tutto il resto!) iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # 3. Invalidi iptables -A INPUT -m conntrack --ctstate INVALID -j DROP # 4. Anti-spoofing iptables -A INPUT -i eth0 -s 127.0.0.0/8 -j DROP iptables -A INPUT -i eth0 -s 10.0.0.0/8 -j DROP # 5. ICMP iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s -j ACCEPT # 6. Servizi iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT iptables -A INPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate NEW -j ACCEPT # 7. Log iptables -A INPUT -m limit --limit 5/min -j LOG --log-prefix "FW-DROP: " # 8. Drop finale iptables -A INPUT -j DROP
-j DROP prima delle regole ACCEPT blocchera' tutto il traffico, inclusa la tua sessione SSH!
conntrack per accettare ESTABLISHED,RELATED all'iniziolorecent, limit o hashlimitiptables-save o servizio-m comment --comment "descrizione"-m state — Deprecato, usare -m conntrack --ctstate# Abilita protezione SYN flood net.ipv4.tcp_syncookies = 1 # Disabilita source routing net.ipv4.conf.all.accept_source_route = 0 net.ipv4.conf.default.accept_source_route = 0 # Disabilita ICMP redirect net.ipv4.conf.all.accept_redirects = 0 net.ipv4.conf.default.accept_redirects = 0 net.ipv4.conf.all.send_redirects = 0 # Abilita reverse path filtering (anti-spoofing) net.ipv4.conf.all.rp_filter = 1 net.ipv4.conf.default.rp_filter = 1 # Logga pacchetti marziani (IP impossibili) net.ipv4.conf.all.log_martians = 1 # Ignora ICMP broadcast (anti-smurf) net.ipv4.icmp_echo_ignore_broadcasts = 1 # Ignora ICMP bogus error responses net.ipv4.icmp_ignore_bogus_error_responses = 1 # IP forwarding (solo se fai routing/NAT) net.ipv4.ip_forward = 1 # Disabilita IPv6 se non usato net.ipv6.conf.all.disable_ipv6 = 1 net.ipv6.conf.default.disable_ipv6 = 1
# Blocca IP privati/riservati sull'interfaccia pubblica (eth0) iptables -A INPUT -i eth0 -s 10.0.0.0/8 -j DROP iptables -A INPUT -i eth0 -s 172.16.0.0/12 -j DROP iptables -A INPUT -i eth0 -s 192.168.0.0/16 -j DROP iptables -A INPUT -i eth0 -s 127.0.0.0/8 -j DROP iptables -A INPUT -i eth0 -s 169.254.0.0/16 -j DROP # Link-local iptables -A INPUT -i eth0 -s 224.0.0.0/4 -j DROP # Multicast iptables -A INPUT -i eth0 -s 240.0.0.0/4 -j DROP # Riservato iptables -A INPUT -i eth0 -s 0.0.0.0/8 -j DROP # "This network" iptables -A INPUT -i eth0 -s 100.64.0.0/10 -j DROP # Shared address (CGNAT) iptables -A INPUT -i eth0 -s 192.0.0.0/24 -j DROP # IANA special iptables -A INPUT -i eth0 -s 192.0.2.0/24 -j DROP # TEST-NET-1 iptables -A INPUT -i eth0 -s 198.51.100.0/24 -j DROP # TEST-NET-2 iptables -A INPUT -i eth0 -s 203.0.113.0/24 -j DROP # TEST-NET-3
ipset hash:net per efficienza O(1) invece di regole lineari O(n).
| Caratteristica | SNAT | MASQUERADE |
|---|---|---|
| IP sorgente | Fisso (specificato) | Dinamico (dall'interfaccia) |
| Performance | Migliore (lookup diretto) | Leggermente inferiore (lookup interfaccia) |
| Uso ideale | IP statico | IP dinamico (DHCP, PPPoE) |
| Catena | POSTROUTING | POSTROUTING |
# Prerequisito: abilitare IP forwarding
echo 1 > /proc/sys/net/ipv4/ip_forward
# DNAT: redireziona porta 8080 esterna verso web server interno
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 8080 \
-j DNAT --to-destination 192.168.1.100:80
# Permettere il forwarding del traffico NATtato
iptables -A FORWARD -i eth0 -o eth1 -p tcp --dport 80 \
-d 192.168.1.100 -m conntrack --ctstate NEW -j ACCEPT
# SNAT/MASQUERADE per il traffico di ritorno
iptables -t nat -A POSTROUTING -o eth0 -s 192.168.1.0/24 -j MASQUERADE
# Forwarding bidirezionale con stato
iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth0 -o eth1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
# Limita nuove connessioni TCP per secondo (globale)
iptables -A INPUT -p tcp --syn -m limit --limit 50/s --limit-burst 100 -j ACCEPT
iptables -A INPUT -p tcp --syn -j DROP
# Per-sorgente con hashlimit (piu' preciso)
iptables -A INPUT -p tcp --syn -m hashlimit \
--hashlimit-upto 15/s \
--hashlimit-burst 30 \
--hashlimit-mode srcip \
--hashlimit-name syn_flood \
-j ACCEPT
iptables -A INPUT -p tcp --syn -j DROP
# Registra nuove connessioni SSH
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW \
-m recent --set --name SSH --rsource
# Blocca se piu' di 4 tentativi in 60 secondi
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW \
-m recent --update --seconds 60 --hitcount 4 --name SSH --rsource \
-j DROP
# Accetta le connessioni normali
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT
# Catena dedicata per port scan detection
iptables -N PORT_SCAN
iptables -A PORT_SCAN -m recent --set --name portscan --rsource
iptables -A PORT_SCAN -m recent --update --seconds 300 --hitcount 10 --name portscan --rsource -j DROP
iptables -A PORT_SCAN -j RETURN
# Rileva scan su porte comuni non aperte
iptables -A INPUT -p tcp -m multiport --dports 23,135,139,445,1433,3389 \
-m conntrack --ctstate NEW -j PORT_SCAN
# Max 20 connessioni HTTP per singolo IP
iptables -A INPUT -p tcp --dport 80 -m connlimit --connlimit-above 20 \
--connlimit-mask 32 -j REJECT --reject-with tcp-reset
# Max 50 connessioni per /24
iptables -A INPUT -p tcp --dport 443 -m connlimit --connlimit-above 50 \
--connlimit-mask 24 -j DROP
ipset permette di gestire insiemi di IP/reti/porte con ricerca O(1) tramite hash. E' molto piu' efficiente di regole iptables multiple.
| Scenario | Senza ipset | Con ipset |
|---|---|---|
| Bloccare 1000 IP | 1000 regole (O(n) per pacchetto) | 1 regola + 1 set (O(1) per pacchetto) |
| Whitelist paesi | Migliaia di regole per i CIDR | 1 set hash:net |
| Blocco IP+porta | Regole incrociate complesse | 1 set hash:ip,port |
# Blacklist IP singoli ipset create blacklist hash:ip hashsize 4096 maxelem 100000 ipset add blacklist 1.2.3.4 ipset add blacklist 5.6.7.8 timeout 3600 # scadenza 1h iptables -A INPUT -m set --match-set blacklist src -j DROP # Whitelist reti ipset create trusted_nets hash:net ipset add trusted_nets 192.168.1.0/24 ipset add trusted_nets 10.0.0.0/8 iptables -A INPUT -m set --match-set trusted_nets src -j ACCEPT # Blocco IP+porta (es. ban da servizio specifico) ipset create service_ban hash:ip,port ipset add service_ban 1.2.3.4,tcp:80 ipset add service_ban 5.6.7.8,tcp:443 iptables -A INPUT -m set --match-set service_ban src,dst -j DROP # Set con timeout automatico (ban temporanei) ipset create temp_ban hash:ip timeout 3600 counters ipset add temp_ban 1.2.3.4 timeout 1800 # 30 minuti
# Metodo sicuro: crea nuovo set, swap, elimina vecchio ipset create blacklist_new hash:ip # ... popola blacklist_new ... ipset swap blacklist blacklist_new ipset destroy blacklist_new # Questo evita finestre temporali senza protezione
# SEMPRE con rate limiting (previene riempimento disco/DoS)
iptables -A INPUT -m limit --limit 5/min --limit-burst 10 \
-j LOG --log-prefix "FW-INPUT-DROP: " --log-level 4
# Log per catena specifica
iptables -N LOG_AND_DROP
iptables -A LOG_AND_DROP -m limit --limit 10/min \
-j LOG --log-prefix "FW-BLOCKED: " --log-level 4
iptables -A LOG_AND_DROP -j DROP
# Uso:
iptables -A INPUT -p tcp --dport 23 -j LOG_AND_DROP
# /etc/rsyslog.d/iptables.conf
:msg, contains, "FW-" /var/log/firewall.log
& stop
# Rotazione: /etc/logrotate.d/firewall
/var/log/firewall.log {
daily
rotate 30
compress
missingok
notifempty
}
# Visualizza regole con contatori iptables -nvL --line-numbers iptables -t nat -nvL --line-numbers # Resetta contatori iptables -Z # Traccia pacchetti (debug avanzato) iptables -t raw -A PREROUTING -p tcp --dport 80 -j TRACE # Poi: cat /proc/net/nf_log oppure dmesg | grep TRACE # Monitor conntrack in tempo reale conntrack -E # eventi conntrack -L # lista connessioni conntrack -C # conteggio
-j TRACE genera un log per ogni regola attraversata da ogni pacchetto. Usare solo in debug e su traffico filtrato, mai in produzione su tutto.
Le regole iptables sono in memoria e si perdono al reboot. Ecco come renderle persistenti.
# Installare iptables-persistent apt install iptables-persistent # Salva le regole correnti iptables-save > /etc/iptables/rules.v4 ip6tables-save > /etc/iptables/rules.v6 # Oppure con il comando netfilter-persistent save # Le regole vengono caricate automaticamente al boot
# Con il servizio iptables systemctl enable iptables iptables-save > /etc/sysconfig/iptables ip6tables-save > /etc/sysconfig/ip6tables # Oppure service iptables save
#!/bin/bash # /etc/network/if-up.d/firewall iptables-restore < /etc/iptables.rules
# Prima di testare regole rischiose, programma un ripristino:
iptables-save > /tmp/iptables.backup
echo "iptables-restore < /tmp/iptables.backup" | at now + 5 minutes
# Se tutto funziona, cancella il job:
atrm $(atq | awk '{print $1}')
# Alternativa con systemd:
systemd-run --on-active=300 iptables-restore /tmp/iptables.backup
iptables -P INPUT DROP # Ops, non ho aggiunto la regola SSH prima!
# Prima la regola SSH, POI la policy iptables -A INPUT -p tcp --dport 22 -j ACCEPT iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT iptables -P INPUT DROP
# Senza stato, ogni pacchetto di ritorno viene valutato iptables -A INPUT -p tcp --dport 80 -j ACCEPT iptables -A INPUT -j DROP # Il server risponde, ma i pacchetti ACK vengono droppati!
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT iptables -A INPUT -p tcp --dport 80 -m conntrack --ctstate NEW -j ACCEPT iptables -A INPUT -j DROP
# Accetta TUTTO da qualsiasi IP iptables -A INPUT -j ACCEPT
# Specifico: protocollo + porta + sorgente
iptables -A INPUT -p tcp --dport 22 -s 10.0.0.0/8 \
-m conntrack --ctstate NEW -j ACCEPT
# -A aggiunge in fondo - dopo il DROP finale non serve iptables -A INPUT -j DROP iptables -A INPUT -p tcp --dport 80 -j ACCEPT # Mai raggiunto!
# Usa -I per inserire in posizione specifica iptables -I INPUT 5 -p tcp --dport 80 -j ACCEPT # Oppure: aggiungi le regole nell'ordine corretto dall'inizio
# DNAT senza regola FORWARD = pacchetti droppati iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to 10.0.0.2:80
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to 10.0.0.2:80 iptables -A FORWARD -p tcp -d 10.0.0.2 --dport 80 -j ACCEPT echo 1 > /proc/sys/net/ipv4/ip_forward
# Su un server trafficato, riempie il disco in ore iptables -A INPUT -j LOG --log-prefix "DROP: "
iptables -A INPUT -m limit --limit 5/min --limit-burst 10 \
-j LOG --log-prefix "DROP: " --log-level 4
#!/bin/bash
# Template: Web Server con protezione completa
set -e
# Pulizia
iptables -F
iptables -X
iptables -t nat -F
iptables -t mangle -F
# Policy di default
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT
# Catene personalizzate
iptables -N LOG_DROP
iptables -A LOG_DROP -m limit --limit 5/min -j LOG --log-prefix "FW-DROP: " --log-level 4
iptables -A LOG_DROP -j DROP
# 1. Loopback
iptables -A INPUT -i lo -j ACCEPT
# 2. Connessioni stabilite
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -m conntrack --ctstate INVALID -j DROP
# 3. ICMP (limitato)
iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 2/s --limit-burst 5 -j ACCEPT
# 4. SSH con protezione brute-force
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --set --name SSH
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 5 --name SSH -j LOG_DROP
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT
# 5. HTTP/HTTPS con connlimit
iptables -A INPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate NEW \
-m connlimit --connlimit-above 50 --connlimit-mask 32 -j LOG_DROP
iptables -A INPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate NEW -j ACCEPT
# 6. Log e drop finale
iptables -A INPUT -j LOG_DROP
echo "Firewall Web Server configurato."
#!/bin/bash # Template: Gateway NAT con 2 interfacce # eth0 = WAN (pubblica), eth1 = LAN (192.168.1.0/24) set -e # Abilita forwarding echo 1 > /proc/sys/net/ipv4/ip_forward # Pulizia iptables -F && iptables -X iptables -t nat -F && iptables -t nat -X iptables -t mangle -F # Policy iptables -P INPUT DROP iptables -P FORWARD DROP iptables -P OUTPUT ACCEPT # === INPUT (per il gateway stesso) === iptables -A INPUT -i lo -j ACCEPT iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT iptables -A INPUT -m conntrack --ctstate INVALID -j DROP # SSH solo dalla LAN iptables -A INPUT -i eth1 -p tcp --dport 22 -j ACCEPT # DHCP dalla LAN iptables -A INPUT -i eth1 -p udp --dport 67 -j ACCEPT # DNS dalla LAN (se il gateway fa da DNS) iptables -A INPUT -i eth1 -p udp --dport 53 -j ACCEPT iptables -A INPUT -i eth1 -p tcp --dport 53 -j ACCEPT # ICMP iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 2/s -j ACCEPT iptables -A INPUT -m limit --limit 5/min -j LOG --log-prefix "GW-INPUT-DROP: " iptables -A INPUT -j DROP # === FORWARD (transito LAN <-> WAN) === # LAN -> WAN: tutto permesso iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT # WAN -> LAN: solo connessioni stabilite iptables -A FORWARD -i eth0 -o eth1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Anti-spoofing: niente IP privati dalla WAN iptables -A FORWARD -i eth0 -s 10.0.0.0/8 -j DROP iptables -A FORWARD -i eth0 -s 172.16.0.0/12 -j DROP iptables -A FORWARD -i eth0 -s 192.168.0.0/16 -j DROP # Log forward drops iptables -A FORWARD -m limit --limit 5/min -j LOG --log-prefix "GW-FWD-DROP: " iptables -A FORWARD -j DROP # === NAT === iptables -t nat -A POSTROUTING -o eth0 -s 192.168.1.0/24 -j MASQUERADE # === Port forwarding (esempio: web server interno) === # iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j DNAT --to 192.168.1.100:80 # iptables -A FORWARD -i eth0 -p tcp -d 192.168.1.100 --dport 80 -j ACCEPT # === MSS Clamping (per PPPoE/VPN) === iptables -t mangle -A FORWARD -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --clamp-mss-to-pmtu echo "Gateway NAT configurato."
#!/bin/bash # Template: Server con Docker # ATTENZIONE: Docker modifica iptables autonomamente! # Queste regole si integrano con Docker, non lo sostituiscono. set -e # Catena DOCKER-USER: Docker la rispetta per filtraggio personalizzato # (Docker gestisce FORWARD e nat autonomamente, NON toccare DOCKER chain) # === Protezione INPUT del host === iptables -A INPUT -i lo -j ACCEPT iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT iptables -A INPUT -m conntrack --ctstate INVALID -j DROP # SSH iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT # Docker API (SOLO locale o da rete trusted) # iptables -A INPUT -p tcp --dport 2376 -s 10.0.0.0/8 -j ACCEPT # ICMP iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 2/s -j ACCEPT iptables -A INPUT -m limit --limit 5/min -j LOG --log-prefix "HOST-DROP: " iptables -P INPUT DROP # === DOCKER-USER: filtro traffico verso i container === # Questa catena viene attraversata da TUTTO il traffico verso i container # Docker la crea automaticamente, noi aggiungiamo regole # Permetti traffico dalla rete locale iptables -I DOCKER-USER -s 192.168.1.0/24 -j ACCEPT # Permetti connessioni stabilite iptables -I DOCKER-USER -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Blocca accesso diretto ai container da IP esterni (esempio) # iptables -I DOCKER-USER -i eth0 -d 172.17.0.0/16 -j DROP # IMPORTANTE: lasciare RETURN alla fine di DOCKER-USER iptables -A DOCKER-USER -j RETURN echo "Docker host firewall configurato." echo "NOTA: Le porte esposte con -p nei container sono gestite da Docker." echo "Usa DOCKER-USER per filtraggio aggiuntivo."
#!/bin/bash
# Template minimo per server appena installato
set -e
iptables -F && iptables -X
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -m conntrack --ctstate INVALID -j DROP
iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW \
-m recent --set --name SSH
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW \
-m recent --update --seconds 60 --hitcount 4 --name SSH -j DROP
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT
iptables -A INPUT -m limit --limit 5/min -j LOG --log-prefix "FW: "
iptables -A INPUT -j DROP
| Stato | Significato | Uso tipico |
|---|---|---|
NEW |
Primo pacchetto di una nuova connessione | Filtrare in base a servizio/porta |
ESTABLISHED |
Parte di connessione gia' vista bidirezionalmente | Accettare sempre (regola in cima) |
RELATED |
Correlata a connessione esistente (es. FTP data, ICMP error) | Accettare con ESTABLISHED |
INVALID |
Non associabile a nessuna connessione | Sempre DROP (possibili attacchi) |
UNTRACKED |
Esplicitamente escluso dal tracking (con -j NOTRACK) | Server ad altissimo traffico |
# Aumenta tabella conntrack (default: 65536) echo 262144 > /proc/sys/net/netfilter/nf_conntrack_max # Ridurre timeout per connessioni non piu' attive echo 600 > /proc/sys/net/netfilter/nf_conntrack_tcp_timeout_established echo 30 > /proc/sys/net/netfilter/nf_conntrack_tcp_timeout_time_wait echo 120 > /proc/sys/net/netfilter/nf_conntrack_tcp_timeout_close_wait # Monitora l'uso cat /proc/sys/net/netfilter/nf_conntrack_count # connessioni attive cat /proc/sys/net/netfilter/nf_conntrack_max # massimo # NOTRACK per servizi stateless ad alto volume (es. DNS server) iptables -t raw -A PREROUTING -p udp --dport 53 -j NOTRACK iptables -t raw -A OUTPUT -p udp --sport 53 -j NOTRACK
# FTP attivo richiede il helper per tracciare la connessione dati modprobe nf_conntrack_ftp # Assegna il helper esplicitamente (best practice moderna) iptables -t raw -A PREROUTING -p tcp --dport 21 -j CT --helper ftp # SIP (VoIP) modprobe nf_conntrack_sip iptables -t raw -A PREROUTING -p udp --dport 5060 -j CT --helper sip # TFTP modprobe nf_conntrack_tftp iptables -t raw -A PREROUTING -p udp --dport 69 -j CT --helper tftp
-j CT --helper nella tabella raw. Questo e' piu' sicuro.
iptables ha servito il mondo Linux per oltre 20 anni, ma presenta limiti strutturali che hanno portato allo sviluppo di nftables:
| Problema di iptables | Come nftables lo risolve |
|---|---|
| 4 tool separati: iptables, ip6tables, arptables, ebtables, ognuno con la propria sintassi e le proprie tabelle kernel | 1 solo tool (nft) con famiglie: ip, ip6, inet (entrambi), arp, bridge, netdev |
| Aggiornamento atomico impossibile: ogni regola e' una syscall separata. Con 500 regole = 500 syscall, con finestra di inconsistenza | Aggiornamento atomico nativo: l'intero ruleset viene inviato al kernel in una sola operazione Netlink |
Match extension come moduli kernel: ogni -m modulo richiede un modulo kernel separato (conntrack, limit, multiport, etc.) |
Espressioni generiche nella VM: nftables compila le regole in bytecode eseguito da una VM nel kernel. Nessun modulo extra necessario |
| Tabelle fisse: filter, nat, mangle, raw, security - non puoi crearne di nuove o rinominarle | Tabelle utente: crei le tabelle che vuoi, con i nomi che vuoi. L'hook (input, forward, etc.) e' sulla catena, non sulla tabella |
| Niente set nativi: devi usare ipset come tool esterno | Set e mappe native: set, mappe e verdict map sono parte del linguaggio. Supporto intervalli, timeout, contatori per elemento |
| Duplicazione IPv4/IPv6: regole identiche vanno scritte due volte (iptables + ip6tables) | Famiglia inet: una sola regola vale per IPv4 e IPv6 contemporaneamente |
| Niente concatenazioni: non puoi matchare combinazioni complesse (ip+porta+interfaccia) in un solo lookup | Concatenazioni: ip saddr . tcp dport { 10.0.0.1 . 22, 10.0.0.2 . 80 } |
| Performance lineare: le regole sono valutate sequenzialmente, O(n) | Lookup O(1) con set: i set usano hash table o alberi, molto piu' efficienti con tante entry |
| Anno | Evento |
|---|---|
| 2000 | iptables incluso nel kernel Linux 2.4 (sostituisce ipchains) |
| 2008 | Inizio sviluppo di nftables da parte del team Netfilter |
| 2014 | nftables incluso nel kernel Linux 3.13 |
| 2017 | Kernel 4.10: supporto set con intervalli, mappe e contatori |
| 2019 | Debian 10 (Buster) e RHEL 8 adottano nftables come default |
| 2020 | Kernel 5.6+: flowtable per offloading hardware |
| 2021 | iptables dichiarato in "maintenance mode": solo bugfix, nessuna feature nuova |
| 2023+ | La maggior parte delle distribuzioni usa iptables-nft (backend nftables con sintassi iptables compatibile) |
iptables -V - se riporta nf_tables stai gia' usando nftables sotto il cofano tramite il layer di compatibilita'.
In nftables non ci sono tabelle fisse. Ogni catena si aggancia a un hook con una priority numerica.
Piu' catene possono condividere lo stesso hook: vengono eseguite in ordine di priorita' (valore basso = prima).
A differenza di iptables dove tabelle e catene sono predefinite, in nftables la struttura e' completamente definita dall'utente:
# Famiglia -> Tabella -> Catena -> Regole
# -> Set
table inet mio_firewall { # famiglia: inet, nome tabella: mio_firewall
set blocked_ips { # set nativo (rimpiazza ipset)
type ipv4_addr
flags interval
elements = { 10.0.0.0/8, 192.168.0.0/16 }
}
chain ingresso { # catena con hook input
type filter hook input priority filter; policy drop;
# Regole: espressioni + verdetto
iifname "lo" accept
ct state established,related accept
ct state invalid drop
ip saddr @blocked_ips drop
tcp dport { 22, 80, 443 } ct state new accept
counter log prefix "dropped: " drop
}
}
| Famiglia | Descrizione | Hook disponibili |
|---|---|---|
ip | Solo traffico IPv4 | prerouting, input, forward, output, postrouting |
ip6 | Solo traffico IPv6 | prerouting, input, forward, output, postrouting |
inet | IPv4 + IPv6 unificati | prerouting, input, forward, output, postrouting |
arp | Traffico ARP | input, output |
bridge | Traffico bridge layer 2 | prerouting, input, forward, output, postrouting |
netdev | Traffico su interfaccia (ingress) | ingress, egress |
| Tipo | Uso | Verdetti possibili |
|---|---|---|
filter | Filtraggio pacchetti (accept/drop) | accept, drop, reject, jump, goto, return |
nat | Network Address Translation | accept, drop, snat, dnat, masquerade, redirect |
route | Rerouting (hook output) | accept, drop |
# Protocollo + campo
ip saddr 192.168.1.0/24 # indirizzo sorgente IPv4
ip6 daddr fd00::/64 # destinazione IPv6
tcp dport 22 # porta destinazione TCP
udp sport 53 # porta sorgente UDP
icmp type echo-request # tipo ICMP
# Set anonimi (inline)
tcp dport { 80, 443, 8080 } # match su piu' porte
ip saddr { 10.0.0.1, 10.0.0.2 } # match su piu' IP
# Meta (metadati del pacchetto)
iifname "eth0" # interfaccia ingresso
oifname "eth1" # interfaccia uscita
meta l4proto tcp # protocollo layer 4
meta mark 0x1 # mark del pacchetto
meta length > 1500 # lunghezza pacchetto
# Connection tracking
ct state new # nuova connessione
ct state established,related # connessione stabilita o correlata
ct state != invalid # non invalid
# Negazione
tcp dport != 22 # NOT porta 22
ip saddr != 192.168.1.0/24 # NOT da questa rete
# Concatenazioni
ip saddr . tcp dport { 10.0.0.1 . 22, 10.0.0.2 . 80 }
# Verdetti (terminano la valutazione) accept # accetta drop # scarta reject # rifiuta con ICMP error reject with icmp type admin-prohibited reject with tcp reset # Statement (non terminano) counter # conta pacchetti/bytes counter packets 0 bytes 0 log # logga log prefix "firewall: " level warn limit rate 5/minute burst 10 packets # rate limiting limit rate over 1 mbytes/second # limita banda # NAT dnat to 192.168.1.100:80 # destination NAT snat to 203.0.113.1 # source NAT masquerade # NAT dinamico redirect to :8080 # redirect a porta locale # Combinazioni: statement + verdetto counter log prefix "ssh: " accept # conta, logga, accetta limit rate 3/minute burst 5 packets accept # rate limit poi accetta
# Definire un set
set blacklist {
type ipv4_addr
flags interval # supporto CIDR/range
timeout 1h # scadenza automatica
elements = { 10.0.0.0/8, 172.16.0.0/12 }
}
# Usare un set in una regola
ip saddr @blacklist drop
# Aggiungere/rimuovere elementi
nft add element inet filter blacklist { 192.168.1.1 }
nft delete element inet filter blacklist { 192.168.1.1 }
# Set di porte
set allowed_ports {
type inet_service
elements = { 22, 80, 443 }
}
tcp dport @allowed_ports accept
# Mappe (valore -> azione)
tcp dport vmap { 22 : accept, 80 : accept, 443 : accept, * : drop }
# Mappe (valore -> valore) per NAT
dnat to tcp dport map { 80 : 192.168.1.100, 443 : 192.168.1.200 }
| iptables | nftables |
|---|---|
iptables -A INPUT -j ACCEPT | nft add rule inet filter input accept |
iptables -P INPUT DROP | nft add chain inet filter input { policy drop; } |
iptables -I INPUT 2 | nft insert rule inet filter input position 2 |
iptables -D INPUT 3 | nft delete rule inet filter input handle 3 |
iptables -F | nft flush chain inet filter input |
iptables -X MYCHAIN | nft delete chain inet filter MYCHAIN |
iptables -L -n -v | nft list ruleset |
iptables-save | nft list ruleset |
iptables-restore < file | nft -f file |
iptables -Z | nft reset counters |
| iptables | nftables |
|---|---|
-p tcp --dport 22 | tcp dport 22 |
-p tcp -m multiport --dports 80,443 | tcp dport { 80, 443 } |
-s 192.168.1.0/24 | ip saddr 192.168.1.0/24 |
-d ! 10.0.0.0/8 | ip daddr != 10.0.0.0/8 |
-i eth0 | iifname "eth0" |
-o eth1 | oifname "eth1" |
-m conntrack --ctstate NEW | ct state new |
-m state --state ESTABLISHED | ct state established |
-m limit --limit 5/min --limit-burst 10 | limit rate 5/minute burst 10 packets |
-m recent --set --name SSH | add @ssh_recent { ip saddr } (con set dinamico) |
-m set --match-set myset src | ip saddr @myset |
-m mac --mac-source AA:BB:CC:DD:EE:FF | ether saddr AA:BB:CC:DD:EE:FF |
-m comment --comment "testo" | comment "testo" |
-m string --string "GET" --algo bm | (non supportato direttamente, usare nfqueue) |
| iptables | nftables |
|---|---|
-j ACCEPT | accept |
-j DROP | drop |
-j REJECT --reject-with icmp-port-unreachable | reject |
-j REJECT --reject-with tcp-reset | reject with tcp reset |
-j LOG --log-prefix "fw: " --log-level 4 | log prefix "fw: " level warn |
-j SNAT --to-source 1.2.3.4 | snat to 1.2.3.4 |
-j DNAT --to-destination 10.0.0.1:80 | dnat to 10.0.0.1:80 |
-j MASQUERADE | masquerade |
-j REDIRECT --to-ports 8080 | redirect to :8080 |
-j MARK --set-mark 0x1 | meta mark set 0x1 |
-j TCPMSS --clamp-mss-to-pmtu | tcp option maxseg size set rt mtu |
-j NOTRACK | notrack |
# Converti intero ruleset iptables in formato nftables iptables-save | iptables-restore-translate -f /dev/stdin # Converti una singola regola iptables-translate -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT # Output: nft add rule ip filter INPUT tcp dport 22 ct state new counter accept # Converti ip6tables ip6tables-save | ip6tables-restore-translate -f /dev/stdin
# === IPTABLES === *filter :INPUT DROP [0:0] :FORWARD DROP [0:0] :OUTPUT ACCEPT [0:0] -A INPUT -i lo -j ACCEPT -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT -A INPUT -p tcp -m multiport --dports 22,80,443 -m conntrack --ctstate NEW -j ACCEPT -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s -j ACCEPT -A FORWARD -i eth1 -o eth0 -j ACCEPT -A FORWARD -i eth0 -o eth1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT COMMIT *nat :POSTROUTING ACCEPT [0:0] -A POSTROUTING -o eth0 -s 192.168.1.0/24 -j MASQUERADE COMMIT
# === NFTABLES equivalente ===
table inet firewall {
chain input {
type filter hook input priority filter; policy drop;
iifname "lo" accept
ct state established,related accept
tcp dport { 22, 80, 443 } ct state new accept
icmp type echo-request limit rate 1/second accept
}
chain forward {
type filter hook forward priority filter; policy drop;
iifname "eth1" oifname "eth0" accept
iifname "eth0" oifname "eth1" ct state established,related accept
}
chain output {
type filter hook output priority filter; policy accept;
}
}
table ip nat {
chain postrouting {
type nat hook postrouting priority srcnat;
oifname "eth0" ip saddr 192.168.1.0/24 masquerade
}
}
iptables-nft permette di usare la sintassi iptables con il backend nftables. Molte distribuzioni moderne lo usano di default. Controlla con iptables -V: se riporta "nf_tables" stai gia' usando nftables sotto il cofano. Non mescolare iptables-legacy e iptables-nft sullo stesso sistema.
ipset-translate puo' aiutare ma non copre tutti i casi. I set nftables sono piu' potenti (timeout per elemento, contatori per elemento, concatenazioni) ma la sintassi e' diversa.
| Comando | Descrizione |
|---|---|
iptables -L -n -v --line-numbers | Lista regole con dettagli e numeri |
iptables -t nat -L -n -v | Lista regole NAT |
iptables -S | Mostra regole in formato comando |
iptables-save | Esporta tutte le regole |
iptables-restore < file | Importa regole (atomico) |
iptables -F | Flush tutte le regole (catena filter) |
iptables -X | Elimina catene utente |
iptables -Z | Azzera contatori |
iptables -D INPUT 3 | Elimina regola #3 dalla catena INPUT |
iptables -I INPUT 2 ... | Inserisci regola in posizione 2 |
iptables -R INPUT 3 ... | Sostituisci regola #3 |
iptables -N MYCHAIN | Crea catena personalizzata |
| Match | Opzioni chiave | Esempio |
|---|---|---|
conntrack | --ctstate | -m conntrack --ctstate NEW,ESTABLISHED |
multiport | --dports, --sports | -m multiport --dports 80,443,8080 |
limit | --limit, --limit-burst | -m limit --limit 5/min --limit-burst 10 |
hashlimit | --hashlimit-upto, --hashlimit-mode | -m hashlimit --hashlimit-upto 10/s --hashlimit-mode srcip --hashlimit-name x |
recent | --set, --rcheck, --update | -m recent --update --seconds 60 --hitcount 4 --name SSH |
connlimit | --connlimit-above | -m connlimit --connlimit-above 20 --connlimit-mask 32 |
set | --match-set | -m set --match-set blacklist src |
comment | --comment | -m comment --comment "Allow SSH" |
string | --string, --algo | -m string --string "GET /" --algo bm |
iprange | --src-range | -m iprange --src-range 10.0.0.1-10.0.0.100 |
time | --timestart, --weekdays | -m time --timestart 08:00 --timestop 18:00 |
mac | --mac-source | -m mac --mac-source AA:BB:CC:DD:EE:FF |
owner | --uid-owner | -m owner --uid-owner 1000 |
addrtype | --src-type, --dst-type | -m addrtype --dst-type LOCAL |
| Porta | Servizio | Porta | Servizio |
|---|---|---|---|
| 22 | SSH | 443 | HTTPS |
| 25 | SMTP | 587 | SMTP Submission |
| 53 | DNS | 993 | IMAPS |
| 80 | HTTP | 3306 | MySQL |
| 110 | POP3 | 5432 | PostgreSQL |
| 143 | IMAP | 6379 | Redis |
| 389 | LDAP | 27017 | MongoDB |