Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
iptables-essentials — Iptables Essenziali: Regole e Comandi Comuni per il Firewall. | Kitploit
Strumenti/GitHubGitHub/trimstray/iptables-essentials
Audit di ConfigurazioneSicurezza di ReteApprendimento e FormazioneRisorse Curate
GitHubtrimstray/iptables-essentials

iptables-essentials

Iptables Essenziali: Regole e Comandi Comuni per il Firewall.

Vedi Repository
1.6k28921 anno faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Iptables Essenziali: Regole e Comuni del Firewall


Pull Requests MIT License


☑️ DA FARE

  • Aggiungere esempi utili di configurazione di Iptables
  • Aggiungere una configurazione utile di Kernel Settings (sysctl)
  • Aggiungere link a risorse esterne utili
  • Aggiungere esempi avanzati di configurazione, comandi, regole

Indice dei contenuti

  • Strumenti per aiutarti a configurare Iptables
Manuali/Guide/Tutorial
  • Configurazione utile di Kernel Settings (sysctl)
    • rp_filter
    • log_martians
    • send_redirects
    • accept_source_route
    • accept_redirects
    • tcp_syncookies
    • icmp_echo_ignore_broadcasts
    • ip_forward
  • Come funziona?
  • Regole Iptables
    • Salvare le regole
      • Basato su Debian
      • Basato su RedHat
    • Elencare tutte le regole iptables attive con verbose
    • Elencare tutte le regole iptables attive con righe numeriche e verbose
    • Stampare tutte le regole iptables attive
    • Elencare le regole come tabelle per la catena INPUT
    • Stampare tutte le specifiche delle regole nella catena INPUT
    • Mostra conteggi pacchetti e dimensione aggregata
    • Per visualizzare le regole della catena INPUT o OUTPUT con righe numeriche e verbose
    • Eliminare una regola per catena e numero
    • Eliminare una regola per specifica
    • Svuotare tutte le regole, eliminare tutte le catene e accettare tutto
    • Svuotare tutte le catene
    • Svuotare una singola catena
    • Inserire regole del firewall
    • Consentire connessioni al loopback
    • Consentire connessioni in entrata stabilite e correlate
    • Consentire connessioni in uscita stabilite
    • Da interno a esterno
    • Scartare pacchetti non validi
    • Bloccare un indirizzo IP
    • Bloccare un indirizzo IP e rifiutare
    • Bloccare connessioni a un'interfaccia di rete
    • Consentire tutto lo SSH in entrata
    • Consentire SSH in entrata da un indirizzo IP o subnet specifico
    • Consentire SSH in uscita
    • Consentire Rsync in entrata da un indirizzo IP o subnet specifico
    • Consentire tutto l'HTTP in entrata
    • Consentire tutto l'HTTPS in entrata
    • Consentire tutto l'HTTP e HTTPS in entrata
    • Consentire MySQL da un indirizzo IP o subnet specifico
    • Consentire MySQL a un'interfaccia di rete specifica
    • PostgreSQL da un indirizzo IP o subnet specifico
    • Consentire PostgreSQL a un'interfaccia di rete specifica
    • Bloccare la posta SMTP in uscita
    • Consentire tutto lo SMTP in entrata
    • Consentire tutto l'IMAP in entrata
    • Consentire tutto l'IMAPS in entrata
    • Consentire tutto il POP3 in entrata
    • Consentire tutto il POP3S in entrata
    • Scartare indirizzi di rete privata su interfaccia pubblica
    • Scartare tutto il traffico in uscita verso reti Facebook
    • Registrare e scartare pacchetti
    • Registrare e scartare pacchetti con numero limitato di voci di log
    • Scartare o accettare traffico da indirizzo MAC
    • Bloccare o consentire richiesta ICMP Ping
    • Specificare più porte con multiport
    • Bilanciamento del carico con random* o nth*
    • Limitare il numero di connessioni con limit e iplimit*
    • Mantenere un elenco di connessioni recenti da confrontare
    • Confrontare una string* nel payload dati di un pacchetto
    • Regole basate sul tempo con time*
    • Corrispondenza di pacchetti basata su valori TTL
    • Protezione contro la scansione delle porte
    • Protezione brute-force SSH
    • Protezione Syn-flood
      • Mitigare gli SYN Flood con SYNPROXY
    • Bloccare nuovi pacchetti che non sono SYN
    • Controllo forzato dei pacchetti frammentati
    • Pacchetti XMAS
    • Scartare tutti i pacchetti NULL
    • Bloccare valori MSS non comuni
    • Bloccare pacchetti con flag TCP falsi
    • Bloccare pacchetti da subnet private (Spoofing)
  • Esempi di configurazione avanzata
    • Gestione dei pacchetti in Python utilizzando il target NFQUEUE
      • ACCETTA tutti i pacchetti da una sorgente specifica su (filter:INPUT) e SCARTA tutto il resto
      • Scrivi il tuo script di port knocking per proteggere l'accesso SSH

  • Strumenti per aiutarti a configurare Iptables

      :small_orange_diamond: Shorewall - strumento avanzato di configurazione gateway/firewall per GNU/Linux.
      :small_orange_diamond: Firewalld - fornisce un firewall gestito dinamicamente.
      :small_orange_diamond: UFW - strumento di configurazione firewall predefinito per Ubuntu.
      :small_orange_diamond: FireHOL - offre una configurazione semplice e potente per tutti i requisiti di firewall e modellazione del traffico Linux.

    Manuali/Guide/Tutorial

      :small_orange_diamond: Best practices: iptables - di Major Hayden
      :small_orange_diamond: Una guida approfondita a Iptables, il firewall Linux
      :small_orange_diamond: Funzionalità avanzate di netfilter/iptables
      :small_orange_diamond: Firewall Linux con iptables
      :small_orange_diamond: Debug di iptables e trappole comuni del firewall?
      :small_orange_diamond: Netfilter Hacking HOWTO
      :small_orange_diamond: Limitazione della velocità per IP con iptables

    Configurazione utile di Kernel Settings (sysctl)

    rp_filter

    Disabilita la triangolazione del routing. Risponde alle richieste sulla stessa interfaccia, non su un'altra. Protegge anche dallo spoofing IP.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/rp_filter = 1 EOF

    root@kitploit:~
    - [rp_filter e sicurezza Linux LPIC-3](https://www.theurbanpenguin.com/rp_filter-and-lpic-3-linux-security/)
    - [Impostazioni rp_filter del kernel Linux (filtraggio del percorso inverso)](https://www.slashroot.in/linux-kernel-rpfilter-settings-reverse-path-filtering)
    - [Filtraggio del percorso inverso](http://tldp.org/HOWTO/Adv-Routing-HOWTO/lartc.kernel.rpf.html)
    
    ##### log_martians
    
      > _Abilita la registrazione di pacchetti con indirizzi IP malformati._```bash
    cat << EOF >> /etc/sysctl.d/40-custom.conf
    net/ipv4/conf/all/log_martians = 1
    EOF
    
    • Qual è l'utilità della registrazione dei pacchetti martiani?
    send_redirects

    Disabilita l'invio di tutti i pacchetti ICMP di reindirizzamento IPv4 su tutte le interfacce.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/send_redirects = 0 EOF

    root@kitploit:~
    - [Disabilita il source routing](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/security_guide/sect-security_guide-server_security-disable-source-routing)
    - [Cosa sono i redirect ICMP e dovrebbero essere bloccati?](https://askubuntu.com/questions/118273/what-are-icmp-redirects-and-should-they-be-blocked)
    
    ##### accept_source_route
    
      > _Disabilita i pacchetti con instradamento di origine (pacchetti con l'opzione Strict Source Route (SSR) o Loose Source Routing (LSR) impostata)._```bash
    cat << EOF >> /etc/sysctl.d/40-custom.conf
    net/ipv4/conf/all/accept_source_route = 0
    EOF
    
    • Disabilita il routing di origine
    • Il sistema non deve accettare pacchetti con routing di origine IPv4 per impostazione predefinita.
    accept_redirects

    Disabilita l'accettazione dei reindirizzamenti ICMP.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/accept_redirects = 0 EOF

    root@kitploit:~
    - [Cosa sono i reindirizzamenti ICMP e dovrebbero essere bloccati?](https://askubuntu.com/questions/118273/what-are-icmp-redirects-and-should-they-be-blocked)
    - [Il sistema operativo Red Hat Enterprise Linux deve ignorare i messaggi di reindirizzamento del protocollo ICMP (Internet Control Message Protocol) versione 4 (IPv4).](https://www.stigviewer.com/stig/red_hat_enterprise_linux_7/2018-11-28/finding/V-73175)
    
    ##### tcp_syncookies
    
      > _Attiva le protezioni contro SYN-flood (protezione dagli attacchi Denial of Service (DOS))._```bash
    cat << EOF >> /etc/sysctl.d/40-custom.conf
    net/ipv4/tcp_syncookies = 1
    EOF
    
    • Rafforzamento del tuo stack TCP/IP contro gli attacchi SYN Flood
    • Linux: Attivare la protezione TCP SYN Cookie
    • Migliore alternativa per tcp_syncookies in Linux
    icmp_echo_ignore_broadcasts

    Disabilita la risposta ai ping broadcast.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/icmp_echo_ignore_broadcasts = 1 EOF

    root@kitploit:~
    - [A cosa serve il broadcast ICMP?](https://superuser.com/questions/306065/what-is-icmp-broadcast-good-for)
    - [Il sistema non deve rispondere a ICMPv4 inviato a un indirizzo broadcast.](https://www.stigviewer.com/stig/red_hat_enterprise_linux_6/2018-11-28/finding/V-38535)
    
    ##### ip_forward
    
      > _Abilita il routing IP. Richiesto se il tuo firewall protegge una rete, inclusa la NAT._```bash
    cat << EOF >> /etc/sysctl.d/40-custom.conf
    net/ipv4/ip_forward = 1
    EOF
    
    • Introduzione ai router
    • Come abilitare l'IP forwarding in Linux
    • Cos'è l'IP forwarding del kernel?

    Come funziona?

    Master

    Regole di Iptables

    Salvare le regole

    Basato su Debian```bash

    netfilter-persistent save

    root@kitploit:~
    ###### Basato su RedHat```bash
    service iptables save
    

    Elenca tutte le regole iptables attive con verbose```bash

    iptables -n -L -v

    root@kitploit:~
    #### Elenca tutte le regole iptables attive con linee numeriche e verbose```bash
    iptables -n -L -v --line-numbers
    

    Stampa tutte le regole iptables attive```bash

    iptables -S

    root@kitploit:~
    #### Elenca le regole come tabelle per la catena INPUT```bash
    iptables -L INPUT
    

    Stampa tutte le specifiche delle regole nella catena INPUT```bash

    iptables -S INPUT

    root@kitploit:~
    #### Mostra i conteggi dei pacchetti e la dimensione aggregata```bash
    iptables -L INPUT -v
    

    Per visualizzare le regole delle catene INPUT o OUTPUT con numeri di riga e verbose```bash

    iptables -L INPUT -n -v iptables -L OUTPUT -n -v --line-numbers

    root@kitploit:~
    #### Elimina regola per catena e numero```bash
    iptables -D INPUT 10
    

    Elimina regola per specifica```bash

    iptables -D INPUT -m conntrack --ctstate INVALID -j DROP

    root@kitploit:~
    #### Svuota tutte le regole, elimina tutte le catene e accetta tutto```bash
    iptables -P INPUT ACCEPT
    iptables -P FORWARD ACCEPT
    iptables -P OUTPUT ACCEPT
    
    iptables -t nat -F
    iptables -t mangle -F
    iptables -F
    iptables -X
    

    Svuota tutte le catene```bash

    iptables -F

    root@kitploit:~
    #### Svuotare una Singola Catena```bash
    iptables -F INPUT
    

    Inserisci regole firewall```bash

    iptables -I INPUT 2 -s 202.54.1.2 -j DROP

    root@kitploit:~
    #### Consenti connessioni loopback```bash
    iptables -A INPUT -i lo -j ACCEPT
    iptables -A OUTPUT -o lo -j ACCEPT
    

    Consenti connessioni in entrata stabilite e correlate```bash

    iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

    root@kitploit:~
    #### Consenti Connessioni Stabilite in Uscita```bash
    iptables -A OUTPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Da interno a esterno```bash

    iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT

    root@kitploit:~
    #### Scarta Pacchetti Non Validi```bash
    iptables -A INPUT -m conntrack --ctstate INVALID -j DROP
    

    Bloccare un indirizzo IP```bash

    iptables -A INPUT -s 192.168.252.10 -j DROP

    root@kitploit:~
    #### Blocco e Indirizzo IP e Rifiuto```bash
    iptables -A INPUT -s 192.168.252.10 -j REJECT
    

    Blocca le connessioni a un'interfaccia di rete```bash

    iptables -A INPUT -i eth0 -s 192.168.252.10 -j DROP

    root@kitploit:~
    #### Consenti tutto l'SSH in entrata```bash
    iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Consenti SSH in entrata da un indirizzo IP o subnet specifici```bash

    iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Consenti SSH in uscita```bash
    iptables -A OUTPUT -p tcp --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A INPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Consenti Rsync in entrata da un indirizzo IP o sottorete specifici```bash

    iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 873 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 873 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Consenti tutto il traffico HTTP in entrata```bash
    iptables -A INPUT -p tcp --dport 80 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 80 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Consenti tutto l'HTTPS in arrivo```bash

    iptables -A INPUT -p tcp --dport 443 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 443 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Consenti tutto il traffico HTTP e HTTPS in entrata```bash
    iptables -A INPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Consenti MySQL da un indirizzo IP specifico o sottorete```bash

    iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 3306 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 3306 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Abilitare MySQL su un'interfaccia di rete specifica```bash
    iptables -A INPUT -i eth1 -p tcp --dport 3306 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth1 -p tcp --sport 3306 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    PostgreSQL da IP specifico o sottorete```bash

    iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 5432 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 5432 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Consenti PostgreSQL a Interfaccia di Rete Specifica```bash
    iptables -A INPUT -i eth1 -p tcp --dport 5432 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth1 -p tcp --sport 5432 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Blocca la posta SMTP in uscita```bash

    iptables -A OUTPUT -p tcp --dport 25 -j REJECT

    root@kitploit:~
    #### Consenti tutto lo SMTP in arrivo```bash
    iptables -A INPUT -p tcp --dport 25 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 25 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Consenti tutto l'IMAP in arrivo```bash

    iptables -A INPUT -p tcp --dport 143 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 143 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Consenti tutto il traffico IMAPS in entrata```bash
    iptables -A INPUT -p tcp --dport 993 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 993 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Consenti tutto il POP3 in entrata```bash

    iptables -A INPUT -p tcp --dport 110 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 110 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Consenti tutto il POP3S in entrata```bash
    iptables -A INPUT -p tcp --dport 995 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 995 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Scarta l'indirizzo di rete privato sull'interfaccia pubblica```bash

    iptables -A INPUT -i eth1 -s 192.168.0.0/24 -j DROP iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

    root@kitploit:~
    #### Blocca tutto il traffico in uscita verso le reti di Facebook
    
    Ottieni l'AS di Facebook:```bash
    whois -h v4.whois.cymru.com " -v $(host facebook.com | grep "has address" | cut -d " " -f4)" | tail -n1 | awk '{print $1}'
    

    Rilascia:```bash for i in $(whois -h whois.radb.net -- '-i origin AS32934' | grep "^route:" | cut -d ":" -f2 | sed -e 's/^[ \t]*//' | sort -n -t . -k 1,1 -k 2,2 -k 3,3 -k 4,4 | cut -d ":" -f2 | sed 's/$/;/') ; do

    iptables -A OUTPUT -s "$i" -j REJECT

    done

    root@kitploit:~
    #### Registra e Scarta Pacchetti```bash
    iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j LOG --log-prefix "IP_SPOOF A: "
    iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP
    

    Per impostazione predefinita tutto viene registrato nel file /var/log/messages:```bash tail -f /var/log/messages grep --color 'IP SPOOF' /var/log/messages

    root@kitploit:~
    #### Registra e scarta pacchetti con un numero limitato di voci di registro```bash
    iptables -A INPUT -i eth1 -s 10.0.0.0/8 -m limit --limit 5/m --limit-burst 7 -j LOG --log-prefix "IP_SPOOF A: "
    iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP
    

    Scarta o Accetta Traffico da Indirizzo MAC```bash

    iptables -A INPUT -m mac --mac-source 00:0F:EA:91:04:08 -j DROP iptables -A INPUT -p tcp --destination-port 22 -m mac --mac-source 00:0F:EA:91:04:07 -j ACCEPT

    root@kitploit:~
    #### Blocca o Consenti ICMP Ping Request```bash
    iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
    iptables -A INPUT -i eth1 -p icmp --icmp-type echo-request -j DROP
    

    Specificare più porte con `multiport````bash

    iptables -A INPUT -i eth0 -p tcp -m state --state NEW -m multiport --dports ssh,smtp,http,https -j ACCEPT

    root@kitploit:~
    #### Bilanciamento del carico con `random*` o `nth*````bash
    _ips=("172.31.250.10" "172.31.250.11" "172.31.250.12" "172.31.250.13")
    
    for ip in "${_ips[@]}" ; do
      iptables -A PREROUTING -i eth0 -p tcp --dport 80 -m state --state NEW -m nth --counter 0 --every 4 --packet 0 \
        -j DNAT --to-destination ${ip}:80
    done
    

    o```bash _ips=("172.31.250.10" "172.31.250.11" "172.31.250.12" "172.31.250.13")

    for ip in "${_ips[@]}" ; do iptables -A PREROUTING -i eth0 -p tcp --dport 80 -m state --state NEW -m random --average 25
    -j DNAT --to-destination ${ip}:80 done

    root@kitploit:~
    #### Limitare il numero di connessioni con `limit` e `iplimit*````bash
    iptables -A FORWARD -m state --state NEW -p tcp -m multiport --dport http,https -o eth0 -i eth1 \
        -m limit --limit 20/hour --limit-burst 5 -j ACCEPT
    

    o```bash iptables -A INPUT -p tcp -m state --state NEW --dport http -m iplimit --iplimit-above 5 -j DROP

    root@kitploit:~
    #### Mantenere un elenco di connessioni recenti da confrontare```bash
    iptables -A FORWARD -m recent --name portscan --rcheck --seconds 100 -j DROP
    iptables -A FORWARD -p tcp -i eth0 --dport 443 -m recent --name portscan --set -j DROP
    

    Corrispondenza con un string* nel payload dati di un pacchetto```bash

    iptables -A FORWARD -m string --string '.com' -j DROP iptables -A FORWARD -m string --string '.exe' -j DROP

    root@kitploit:~
    #### Regole basate sul tempo con `time*````bash
    iptables -A FORWARD -p tcp -m multiport --dport http,https -o eth0 -i eth1 \
        -m time --timestart 21:30 --timestop 22:30 --days Mon,Tue,Wed,Thu,Fri -j ACCEPT
    

    Matching dei pacchetti basato sui valori TTL```bash

    iptables -A INPUT -s 1.2.3.4 -m ttl --ttl-lt 40 -j REJECT

    root@kitploit:~
    #### Protezione contro la scansione delle porte```bash
    iptables -N port-scanning
    iptables -A port-scanning -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s --limit-burst 2 -j RETURN
    iptables -A port-scanning -j DROP
    

    Protezione da attacchi di forza bruta su SSH```bash

    iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -m recent --set iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 10 -j DROP

    root@kitploit:~
    #### Protezione da Syn-flood```bash
    iptables -N syn_flood
    
    iptables -A INPUT -p tcp --syn -j syn_flood
    iptables -A syn_flood -m limit --limit 1/s --limit-burst 3 -j RETURN
    iptables -A syn_flood -j DROP
    
    iptables -A INPUT -p icmp -m limit --limit  1/s --limit-burst 1 -j ACCEPT
    
    iptables -A INPUT -p icmp -m limit --limit 1/s --limit-burst 1 -j LOG --log-prefix PING-DROP:
    iptables -A INPUT -p icmp -j DROP
    
    iptables -A OUTPUT -p icmp -j ACCEPT
    
    Mitigare gli attacchi SYN Flood con SYNPROXY```bash

    iptables -t raw -A PREROUTING -p tcp -m tcp --syn -j CT --notrack iptables -A INPUT -p tcp -m tcp -m conntrack --ctstate INVALID,UNTRACKED -j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460 iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

    root@kitploit:~
    #### Blocca Nuovi Pacchetti Che Non Sono SYN```bash
    iptables -A INPUT -p tcp ! --syn -m state --state NEW -j DROP
    

    o```bash iptables -t mangle -A PREROUTING -p tcp ! --syn -m conntrack --ctstate NEW -j DROP

    root@kitploit:~
    #### Controllo dei pacchetti Force Fragments```bash
    iptables -A INPUT -f -j DROP
    

    Pacchetti XMAS```bash

    iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP

    root@kitploit:~
    #### Scarta tutti i pacchetti NULL```bash
    iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
    

    Blocca valori MSS non comuni```bash

    iptables -t mangle -A PREROUTING -p tcp -m conntrack --ctstate NEW -m tcpmss ! --mss 536:65535 -j DROP

    root@kitploit:~
    #### Blocca pacchetti con flag TCP falsi```bash
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,RST FIN,RST -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,ACK FIN -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,URG URG -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,FIN FIN -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,PSH PSH -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL ALL -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL NONE -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL FIN,PSH,URG -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,FIN,PSH,URG -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
    

    Bloccare i pacchetti da sottoreti private (Spoofing)```bash

    _subnets=("224.0.0.0/3" "169.254.0.0/16" "172.16.0.0/12" "192.0.2.0/24" "192.168.0.0/16" "10.0.0.0/8" "0.0.0.0/8" "240.0.0.0/5")

    for _sub in "${_subnets[@]}" ; do iptables -t mangle -A PREROUTING -s "$_sub" -j DROP done iptables -t mangle -A PREROUTING -s 127.0.0.0/8 ! -i lo -j DROP

    root@kitploit:~
    ## Esempi di configurazione avanzata
    
    ### Gestione dei pacchetti in Python utilizzando il target NFQUEUE
    
      > _Questo target passa il pacchetto allo spazio utente utilizzando il gestore nfnetlink_queue. Il pacchetto viene inserito nella coda identificata dal suo numero di coda a 16 bit. Lo spazio utente può ispezionare e modificare il pacchetto se desiderato. Lo spazio utente deve quindi scartare o re-iniettare il pacchetto nel kernel._
    
    #### ACCEPT tutti i pacchetti da una sorgente specifica su (filter:INPUT) e DROP tutto il resto
    
      > _Questa regola inoltra tutti i pacchetti filter:INPUT alla coda 1 con il target NFQUEUE._```bash
    iptables -A INPUT -j NFQUEUE --queue-num 1
    

    Script per legare alla coda netfilter 1 e gestire i pacchetti.```python #!/usr/bin/python3

    from netfilterqueue import NetfilterQueue from scapy.all import *

    def packetanalyzer(pkt): ip=IP(pkt.get_payload()) if(ip.src=="192.168.122.1"): print(f"New packet from {ip.src}") pkt.accept() else: pkt.drop()

    nfqueue=NetfilterQueue() nfqueue.bind(1, packetanalyzer) nfqueue.run()

    root@kitploit:~
    #### Scrivi il tuo script di port knocking per proteggere l'accesso ssh
    
      > _DROP tutte le richieste ssh e invia richieste di porte segrete allo spazio utente con il target NFQUEUE._```bash
    iptables -t filter -I INPUT -p tcp --dport 22 -j DROP
    iptables -t raw -I PREROUTING -p tcp --sport 65534 --dport 65535 -j NFQUEUE --queue-num 1
    

    Questo script cattura i pacchetti dalla coda netfilter 1 e verifica SOURCEPORT e SECRETPORT per il port knocking e permette alla sorgente di connettersi a ssh per EXPIRETIME, il default è 30 minuti.```python #!/usr/bin/python3

    from os import system from netfilterqueue import NetfilterQueue from scapy.layers.inet import IP from time import time

    SOURCEPORT=65534 SECRETPORT=65535 EXPIRETIME=30 ALLOWED={}

    def portknocking(pkt): packet=IP(pkt.get_payload()) currtime=time() for item in list(ALLOWED): if(currtime-ALLOWED[item] >= EXPIRETIME*60): del ALLOWED[item] if(packet.sport==SOURCEPORT and packet.dport==SECRETPORT and packet.src not in ALLOWED): print(f"Port {packet.dport} knocked by {packet.src}:{packet.sport}") system(f"iptables -I INPUT -p tcp --dport 22 -s {packet.src} -j ACCEPT") system(f"echo 'iptables -D INPUT -p tcp --dport 22 -s {packet.src} -j ACCEPT' | at now + {EXPIRETIME} minutes") ALLOWED[packet.src]=time() pkt.drop()

    nfqueue=NetfilterQueue() nfqueue.bind(1, portknocking)

    try: nfqueue.run() except KeyboardInterrupt: print("\nExit with Keyboard Interrupt")

    root@kitploit:~
    > _Per bussare alla porta e consentire connessioni ssh dal tuo computer esegui questo comando:_```bash
    nc -p 65534 SERVER 65535
    
    Scarica lo strumento