iptables -- System vom Kernelmodulen (ab Kernel 2.4), Teil des
Netzwerkcodes (IP-Stack) im Kernel. Bietet die Möglichkeit, IP-Pakete
anhand von statischen Regeln zu filtern/manipulieren usw.

Filterung geschieht durch deklarativ in kernel-internen
Datenstrukturen festgehaltene Regeln. Änderung dieser Datenstrukturen
geschieht vom Userspace aus mit dem Programm iptables(8).

IP-Forwarding wird aktiviert durch

echo 1 >/proc/sys/net/ipv4/ip_forward


RTFM: man iptables, IP-Masquerading-Howto


Die Datenstrukturen sehen grob so aus:


//Auf oberster Ebene gibt es Tabellen
<topmost>: list<Table> <<singleton>>


//Jede Tabelle hat einen Namen und eine Sequenz von Chains
Table:
  name: string
  chains: list[Chain]

//Eine Chain enthält eine Policy (Default-Paketverarbeitungsregel, siehe unten)
//und eine Sequenz von Regeln
Chain:
  name: string
  policy: ACCEPT | DROP | QUEUE | RETURN | user_defined_chain_name: string  //policy nur in vordefinierten Chains, nicht in vom Benutzer erzeugten Chains
  rules: list[Rule]


Defaultmaessig existieren folgendende Instanzen der Datenstrukturen:

Table:
  name="filter"
  chains=(
   Chain:
     name="INPUT"
     policy= ACCEPT
     rules= ()

   Chain:
     name="FORWARD"
     policy= ACCEPT
     rules= ()

   Chain:
     name="OUTPUT"
     policy= ACCEPT
     rules= ()

  )


Table:
  name="nat"
  chains=(
   Chain:
     name="PREROUTING"
     policy= ACCEPT
     rules= ()

   Chain:
     name="POSTROUTING"
     policy= ACCEPT
     rules= ()

   Chain:
     name="OUTPUT"
     policy= ACCEPT
     rules= ()

  )


Table:
  name="mangle"
  chains=(
   Chain:
     name="PREROUTING"
     policy: ACCEPT
     rules: ()

   Chain:
     name="OUTPUT"
     policy= ACCEPT
     rules= ()

  )



Ein zu verarbeitendes Paket wird zunächst nach Standardregeln in
best. Chains in best. Tabellen eingeordnet. Die Standardregeln sind:

- Pakete, von diesem Rechner stammen (von einem Prozess auf diesem
  Rechner erzeugt wurden), kommen nach filter/OUTPUT

- Pakete, die an diesen Rechner adressiert sind, kommen nach
  filter/INPUT

- zu routende Pakete (stammen von einem anderen Rechner, sind
  adressiert an einen anderen Rechner) kommen nach filter/FORWARD

TODO: Die Tabellen "nat" und "mangle" muss ich mir noch näher
anschauen.

Anschließend werden die Regeln in der Chain der Reihe nach abgesucht,
bis eine gefunden wird, die auf das zu verarbeitende Paket "matcht"
(wird über Attribute der Regel besteimmt -- s.u.). Wird eine solche
Regel gefunden, entscheidet sie über das weitere Schicksal des
Pakets. Wird keine solche Regel gefunden, entscheidet die Policy der
Chain über das Paket: ACCEPT bedeutet "Paket akzeptieren,
d.h. durchlassen", DROP bedeutet "Paket wegwerfen", QUEUE bedeutet "im
Userspace weiterverarbeiten (TODO: elaborate)", RETURN bedeutet "in
aufrufender Chain (muss existieren) mit der Verbeitung fortfahren
(Regeln in einer Chain können Pakete an andere Chains weiterschicken
-- s.u.)".


//Eine Regel
Rule:

  /////////////////////////////////////////////////////
  //--- Attribute, die zur Entscheidung, ob diese Regel
  //    ein geg. Paket "matcht", herangezogen werden

  //Protokoll des zu verarbeitenden Pakets (IP definiert
  //ein "protocol"-Headerfeld). Default: all
  protocol: tcp | udp | icmp | all

  //Quelladresse, Zieladresse
  source: IPAdddress
  destination: IPAdddress

  //NW-Interface, über das das Paket hereinkam
  in_iface: NWInterface

  //NW-Interface, über das das Paket hinausgehen wird
  in_iface: NWInterface

  //erweiterte Matching-Regeln, die die Entscheidung an
  //andere Kernelmodule writerleiten (da gibt es etliche --
  //siehe "man iptables" und Kernelkonfiguration)
  extended_matching_rules: list[(match_module, module_options)]


  /////////////////////////////////////////////////////
  //--- Weiterverarbeitung des Pakets im Falle eines
  //    erfolgreichen Matches

  //Paket kann akzeptiert, weggeschmissen, an andere Chain
  //(derselben Tabelle?) weitergeleitet, ..... werden
  //Siehe Dokumentation
  target: chainname: string | ACCEPT | DROP | LOG | TOS | ...


Manipulation der Datenstrukturen mit iptables(8):

-- Alle Chains einer Tabelle mit allen ihren Regeln listen:

  iptables [-t <table>] -L -v

  wird die table nicht angegeben, wird "filter" angenommen. Gilt auch
  für alle anderen iptables-Aufrufe.


-- Alle Chains einer Tabelle löschen:

  iptables [-t <table>] -F


-- Policy einer Chain setzen (nur in vordefinierten Chains)

  iptables [-t <table>] -P <chainname> <policy>

  <policy> == ACCEPT | DROP | QUEUE | RETURN | <user-defined chain name>


-- neue Regel an eine Chain anhaengen

  iptables [-t <table>] -A <chainname> <rule-specification...>


  <rule-specification> spezifiziert die Attribute der Regel, z.B.

  -p <port>
  -s <source-address>
  -d <dest-address>
  -i <in-interface>
  -o <out-interface>
  -m <match-extension-module> <module-specific options...>

  -j <target-spec>

    <target-spec> == ACCEPT | DROP | QUEUE | RETURN | <user-defined chain name>
      (siehe oben)


-- neue Regel irgendwo in eine Chain einfuegen

  iptables [-t <table>] -I <chainname> [<rulenum>] <rule-specification...>

  <rulenum>: 1-basierter Index der Regel, *vor* der die neue Regel
  eingefuegt werden soll. Default: 1 (neue Regel an den Anfang setzen)


-- Regel irgendwo in einer Chain loeschen

  iptables [-t <table>] -D <chainname> [<rulenum>] 


-- Regel ersetzen...


-- neue benutzerdefinierte Chain anlegen

  iptables [-t <table>] -N <chainname>