iptables - Netfilter firewall Linux

Cosa fa

#

iptables e' l'interfaccia verso Netfilter, il sottosistema del kernel Linux che filtra i pacchetti di rete. Ogni pacchetto che entra, esce o transita attraverso il sistema viene valutato contro le regole definite nelle chain.

TL;DR

#

Il kernel Linux non ha un firewall "a se'" — ha Netfilter, un framework di hook nel network stack. iptables e' lo strumento che scrive le regole in quel framework. UFW e' un livello sopra: traduce ufw allow 22/tcp in una regola iptables leggibile solo da chi conosce la sintassi.

Stack

#

+---------------------------+
|           UFW             |  ← interfaccia utente (facade)
|   ufw allow 22/tcp        |
+---------------------------+
            |
            v  traduce in
+---------------------------+
|         iptables          |  ← strumento userspace
|  -A INPUT -p tcp          |
|  --dport 22 -j ACCEPT     |
+---------------------------+
            |
            v  scrive regole in
+---------------------------+
|         Netfilter         |  ← kernel Linux
|   hook nel network stack  |
+---------------------------+

Flusso pacchetto

#

               RETE ESTERNA
                    |
                    v
            [ INPUT chain ]   ← pacchetti destinati a questo host
                    |
                    v
            PROCESSO LOCALE
                    |
                    v
            [ OUTPUT chain ]  ← pacchetti generati da questo host
                    |
                    v
               RETE ESTERNA

  Pacchetto in transito (gateway/router):
  RETE A --> [ FORWARD chain ] --> RETE B

Le tre chain fondamentali

#

Ogni chain ha una default policy: ACCEPT (lascia passare) o DROP (blocca silenziosamente). UFW imposta INPUT su DROP quando abilitato.

Analogia OOP

#

• Netfilter = interfaccia (i metodi filterPacket(), dropPacket(), acceptPacket())
• iptables = implementazione concreta di quella interfaccia
• UFW = wrapper/facade sopra iptables che espone un'API semplificata

Come funziona

#

Un pacchetto entra nella chain corretta e viene confrontato con le regole in ordine. Alla prima corrispondenza, si applica l'azione (ACCEPT, DROP, REJECT). Se nessuna regola corrisponde, si applica la default policy.

UFW semplifica questo meccanismo: sudo ufw allow 22/tcp aggiunge automaticamente la regola corretta alla chain INPUT con azione ACCEPT per la porta 22.

Perche' e' nato

#

Prima di UFW, configurare un firewall su Linux richiedeva di scrivere direttamente le regole iptables — sintassi verbosa e facile da sbagliare. UFW (Uncomplicated Firewall) e' nato su Ubuntu per rendere la gestione accessibile. Su server enterprise e distribuzioni non Ubuntu si usa ancora iptables diretto, oppure nftables (il successore moderno).

Scenario Reale

#

In un SOC trovi iptables diretto su server hardened, appliance di rete, e container Docker. Docker stesso manipola le chain iptables per gestire il networking dei container — per questo a volte le regole UFW non bloccano il traffico Docker (Docker scrive le sue regole prima che UFW le valuti).

Collegato a

#

• network — categoria
• ufw — frontend che traduce comandi in regole iptables