iptables heeft een goede gebruikershandleiding (man iptables)
en deze is dus te gebruiken als je ergens meer van wil weten. Als je al
bekend bent met ipchains kan je het hoofdstuk
Differences Between iptables and ipchains
lezen, maar je kan natuurlijk ook gewoon doorlezen.
Er zijn drie standaardreeksen die je niet kan verwijderen, maar je kan ook nog zelf extra reeksen maken. Hier zijn wat opties waarmee je reeksen kan onderhouden:
Er zijn een paar manieren om regels in een reeks te onderhouden:
iptables kan in een kernel module zitten, namelijk iptable_filter.o. Deze module zou automatisch geladen moeten worden zodra je iptables opstart. Deze code kan ook in de kernel ingebouwd worden.
Voordat iptables een keer gestart is zijn alle standaard reeksen leeg en hebben het beleid ACCEPT, ofwel alles doorlaten. Je kan het beleid van de FORWARD reeks wijzigen door de optie "forward=0" mee te geven aan de iptable_filter module. Als op jou computer niet alle reeksen leeg zijn bij het opstarten van je computer, dan kan het zijn dat je distributie in de bootscripts de regels aanpast.
Natuurlijk kan je niets met een pakket filter als je geen regels op kan geven. Meestal wil je gewoon een regel aan het einde toevoegen (-A) of verwijderen. Een regel ergens invoegen (-I) is handig als de volgorde van je regels belangrijk is en een regel vervangen (-R) is handig als bijvoorbeeld een IP-adres verandert.
Elke regel bepaalt welke eigenschappen een pakketje moet hebben zodat deze regel ervoor geld, en wat in dat geval met het pakketje moet gebeuren. Je kan bijvoorbeeld alle pakketjes die van het protocol ICMP zijn en die van het IP 127.0.0.1 afkomen, tegenhouden (DROP). De eigenschappen zijn dan dat het protocol ICMP is, het IP 127.0.0.1. Het doel is DROP.
127.0.0.1 is de loopback adapter. Dit IP heb je zelfs als je geen netwerk hebt. Je kan ICMP pakketjes produceren met het programma ping, wat een pakketje stuurt en meld of het aangekomen is.
# ping -c 1 127.0.0.1
PING 127.0.0.1 (127.0.0.1): 56 data bytes
64 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.2 ms
--- 127.0.0.1 ping statistics ---
1 packets transmitted, 1 packets received, 0% packet loss
round-trip min/avg/max = 0.2/0.2/0.2 ms
# iptables -A INPUT -s 127.0.0.1 -p icmp -j DROP
# ping -c 1 127.0.0.1
PING 127.0.0.1 (127.0.0.1): 56 data bytes
--- 127.0.0.1 ping statistics ---
1 packets transmitted, 0 packets received, 100% packet loss
#
Je ziet hierboven dat de eerste ping wel lukt, maar niet meer als de regel is toegevoegd aan de INPUT reeks.
Een regel kan op twee manieren verwijderd worden: ofwel door het nummer op te geven, ofwel door dezelfde opties op te geven als dat de regel gemaakt werd.
De nummering begint bovenaan met 1 en omdat er nog maar één regel in de reeks staat, is deze regel nummer 1. Deze regel kan dus als volgt verwijdert worden:
# iptables -D INPUT 1
#
De tweede manier is hetzelfde als de regel maken, alleen wordt de -A nu vervangen door -D. Dit is vooral handig als je veel regels hebt en je hebt geen zin om te tellen. Onze regel zouden we dus als volgt verwijderen:
# iptables -D INPUT -s 127.0.0.1 -p icmp -j DROP
#
Behalve protocol (-p) en de herkomst (-s) zijn er nog andere eigenschappen waaraan je bepaalde pakketjes kan herkennen. Hier volgen alle eigenschappen waar je pakketjes mee kan aanduiden.
Herkomst (`-s', `--source' of `--src') en doel (`-d', `--destination' or `--dst') IP adressen kunnen worden opgegeven op vier manieren. Natuurlijk kan je gewoon een IP-adres opgeven, maar je kan ook een hostname gebruiken, zoals `localhost' of `www.linuxhq.com'.
De derde en vierde manieren laten het toe om meerdere IP-adressen te specificeren. `199.95.207.0/255.255.255.0', bijvoorbeeld geeft 255 ip-adressen aan. Ook geldig is `199.95.207.0/24'. Allebei geven ze IP-adressen aan van 199.95.207.0 tot 199.95.207.255.
Twee speciale varianten hiervan zijn 1.2.3.4/32, waar de /32 aangeeft dat het IP-adres helemaal moet voldoen. Dit is standaard. 1.2.3.4/0 kan ook, in welk geval het IP-adres helemaal niet uitmaakt. In dit geval wordt meestal 0/0 opgegeven als IP adres. Dit is standaard als de -s of -d optie weggelaten wordt, dus als er geen herkomst of doel adres opgegeven wordt. Daarom wordt het ook weinig gebruikt:
[ NOTE: `-s 0/0' is redundant here. ]
# iptables -A INPUT -s 0/0 -j DROP
#
Veel opties kunnen voorafgegaan worden door `!', wat staat voor `niet'. `-s ! localhost' heeft dus betrekking tot alle pakketjes, behalve die van localhost afkomen.
Het protocol kan worden opgegeven met `-p' of met `--protocol'. Het protocol kan een nummer zijn, of een naam zoals TCP, UDP of ICMP. Hoofdletters maken hier niets uit.
Ook de protocol optie kan vooraf worden gegaan door een uitroepteken: `-p! TCP' betekent alle pakketjes behalve TCP.
Het opgeven van een protocol is nodig als je regels wilt maken die afhankelijk zijn van het poortnummer waarop een connectie gemaakt wordt. Omdat ICMP geen poorten ondersteund, moet er TCP of UDP opgegeven worden.
De `-i' of `--in-interface' optie geeft de interface (netwerkkaart/modem) aan
waar de pakketjes de computer mee inkomen.
De `-o' of `--out-interface' optie geeft de interface aan waar de pakketjes
uit de computer gaan. Je kan ifconfig gebruiken om een lijst van de
huidige interfaces te krijgen.
Pakketjes die door de INPUT reeks komen hebben geen interface waarmee ze uit de computer gaan. Regels met -o erin zullen dus nooit waar zijn en overgeslagen worden. Bij regels in de OUTPUT reeks werkt het net zo: deze hebben geen interface waarmee ze binnengekomen zijn.
Pakketjes die door de FORWARD reeks gaan hebben zowel een interface waarmee ze naar binnen zijn gekomen, als een interface waarmee ze weer naar buiten gaan.
Je mag ook een interface opgeven die nog niet bestaat. De regel geld niet zolang deze interface niet bestaat, maar zodra deze interface gaat werken treed de regel in werking. Dit is handig voor inbel-connecties, zodat er regels ingevoerd kunnen worden voor het geval er ingebeld wordt.
Bij interfaces werkt het `+' teken als een sterretje; het zal meerdere
interfaces specificeren. -i ppp+ bijvoorbeeld zal voor alle PPP
interfaces gelden, maar niet voor ethernet interfaces.
Ook de interface optie kan voorafgegaan worden door een `!' om de optie om te keren.
Soms is een pakketje te groot om in één keer verstuurd te kunnen worden. In zo'n geval wordt het pakketje opgesplitst in fragmenten en verzonden als meerdere pakketjes. Het probleem wat hierbij komt kijken is dat het eerste pakketje de headers heeft en dus moeiteloos door de regels komt, maar de opvolgende pakketjes hebben de header niet en dus zullen ze tegen gehouden worden.
Als je NAT gebruikt zullen de fragmenten aan elkaar gelijmd worden voordat ze door de reeksen gaan, dus hoef je je over fragmenten geen zorgen te maken.
Is dat niet het geval, dan is het belangrijk om te weten hoe fragmenten behandeld worden door de regels. Als een regel vraagt om bepaalde informatie, kan een fragment die niet verschaffen (het heeft tenslotte geen headers) en dus zal de regel niet gelden voor dit pakketje. Het eerste pakketje zal dus waarschijnlijk door de reeks komen, maar op de andere pakketjes wordt het beleid uitgevoerd.
Om dit probleem te omzeilen kan je fragments doorlaten of tegenhouden met de -f optie.
Het wordt als veilig beschouwd om fragmenten door te laten, hoewel er wel bugs in sommige systemen zitten die het laten crashen als er een los fragment op komt. Deze bugs zijn echter opgelost in moderne software.
De volgende regel zal alle fragmenten tegenhouden die naar 192.168.1.1 gaan:
# iptables -A OUTPUT -f -d 192.168.1.1 -j DROP
#
iptables is makkelijk uit te breiden, wat nieuwe mogelijkheden
met zich mee brengt. Sommige van deze mogelijkheden zijn standaard, andere
worden slechts in enkele gevallen gebruikt. In het laatste geval worden
ze meestal apart verstrekt voor de mensen die de extra mogelijkheid nodig
hebben.
Uitbreidingen van de kernel gaan meestal in de kernel module directory, meestal /lib/modules/2.4.x/net. Als je kernel gecompileerd is met CONFIG_KMOD, dan worden ze geladen als dat nodig is en hoef je ze niet handmatig te laden.
Uitbreidingen van iptables zijn `shared libraries', die meestal in de /usr/local/lib/iptables/ directory staan, hoewel sommige distributies deze in /usr/lib/iptables zetten.
Er zijn twee type uitbreidingen: nieuwe doelen en nieuwe regelopties. Sommige protocollen bieden je automatisch nieuwe regelopties. Deze zijn TCP, UDP en ICMP, die onder andere poorten kunnen specificeren.
Met de `-p' optie wordt automatisch een nieuwe uitbreiding geladen en om expliciet een uitbreiding te laden gebruik je de `-m' optie.
Om hulp te krijgen bij een uitbreiding, geef een optie om deze te laden (`-p', `-j' of `-m') en geef de optie `-h' of `--help':
# iptables -p tcp --help
#
De TCP uitbreidingen worden automatisch geladen als het TCP protocol wordt gekozen. De volgende opties kunnen dan gebruikt worden:
wordt gevolgd door twee lijsten met TCP markeringen. De eerste optie geeft de TCP markeringen (flags) aan die je wilt onderzoeken, de tweede geeft aan welke hiervan geactiveerd moeten zijn. Bijvoorbeeld:
# iptables -A INPUT --protocol tcp --tcp-flags ALL SYN,ACK -j DROP
Deze regel geeft aan dat de TCP pakketjes die de SYN en ACK markeringen hebben geactiveerd, maar de rest niet, tegengehouden moeten worden. `ALL' is hetzelfde als `SYN,ACK,FIN,RST,URG,PSH'. Wil je geen markeringen opgeven, dan kan je `NONE' gebruiken.
Dit is hetzelfde als `--tcp-flags SYN,RST,ACK SYN'.
kan gevolgd worden door een poortnummer of een poortbereik. Voor poortnummers kan je ook namen gebruiken, zoals die in /etc/services worden genoemd. Een poortbereik kan worden aangegeven door twee poorten, gescheiden met een dubbele punt, zoals 1000:2000. Wordt het eerste poortnummer weggelaten (`:2000') dan geldt deze regel voor alle poorten tot 2000. Wordt het laatste poortnummer weggelaten (`1000:') dan geldt deze regel voor de poort 1000 en verder.
is hetzelfde als `--source-port'.
en
zijn hetzelfde als de bovenstaande, alleen geven ze de poorten van de doelbestemming aan in plaats van de herkomst.
wordt gevold door een nummer. Deze regel geldt voor TCP pakketjes met de markering voor dit nummer. Als het pakketje een niet volledige header heeft, dan wordt het pakketje automatisch tegengehouden.
Soms is het handig om TCP connecties maar één kant op te laten werken; je wilt wel connecties maken naar buiten, maar niet andersom.
De oplossing hiervoor is om de pakketjes tegen te houden die een connectie willen openen. Deze pakketjes heten SYN pakketjes (het zijn eigenlijk pakketjes met de SYN markering geactiveerd en de RST en ACK markeringen niet geactiveerd). Door deze pakketjes tegen te houden, wordt er geen connectie gemaakt en zullen dus opvolgende pakketjes genegeerd worden.
De `--syn' optie wordt hiervoor gebruikt. Deze is alleen geldig voor het TCP protocol. Om een regel te maken die geldt voor de pakketjes die een connectie willen maken vanaf 192.168.1.1 kan je de volgende (niet complete) regel gebruiken:
-p TCP -s 192.168.1.1 --syn
Natuurlijk kan ook deze optie weer voorafgegaan worden door een uitroepteken, om pakketjes te specificeren die geen connectie willen maken.
Deze uitbreidingen worden automatisch geladen als er een regel is die het UDP protocol gebruikt (dus als er ergens in de regel `-p udp' voorkomt). Deze uitbreiding brengt de opties `--source-port', `--sport', `--destination-port' en `--dport' met zich mee en deze zijn identiek aan die van TCP.
Deze uitbreiding wordt automatisch geladen als het ICMP protocol gebruikt wordt en komt met slechts één extra optie:
wordt gevolgd door een ICMP type naam (zoals `host-unreachable'), door een nummer wat staat voor een type, of door twee nummers gescheiden door een `/'. De twee nummers staan voor het type en de code van het ICMP pakketje. De nummers kan je opzoeken door `-p icmp --help' te gebruiken.
Deze uitbreidingen kunnen worden gebruikt door de `-m' optie te gebruiken.
Deze module kan gebruikt worden om het hardware adres van de netwerkkaart te gebruiken in je regels. Het werkt alleen met het hardware adres van de kaart waarmee de pakketjes in de computer komen. Het heeft één optie:
gevolgd door een hardware adres, zoals in `--mac-source 00:60:08:91:CC:B7'.
Deze module wordt gebruikt om het aantal geldende regels in een bepaalde tijd terug te dringen. Zo kan je bijvoorbeeld ervoor zorgen dat er slechts 3 keer per uur een berichtje in je log komt te staan als er de hele tijd geldende pakketjes komen. Het specificeerd twee opties:
wordt gevolgd door een nummer en het geeft het aantal pakketjes waar deze regel voor geldt, in een bepaald tijdsbestek. Het nummer kan ook een tijd aangeven, door gebruik te maken van `/second', `/minute', `/hour' of `/day' of de eerste letter ervan. `5/second' is dus hetzelfde als `5/s'.
wordt gevolgd door een nummer en geeft de maximale grens voordat de bovenstaande optie gaat gelden.
Om te kijken hoe het werkt kijken we naar de onderstaande regel, die de pakketjes door de FORWARD reeks logt, maar alleen als ze door de `limit' module heen komen.
# iptables -A FORWARD -m limit -j LOG
De standaard `limit-burst' is vijf en daardoor worden de eerste vijf pakketjes gelogd. Hierna duurt het twintig minuten voordat het volgende pakketje gelogd wordt. Als er 20 minuten lang geen pakketje komt, dan kunnen er na nog eens 20 minuten twee pakketjes doorheen. Na 100 minuten kunnen er dus weer 5 pakketjes doorheen.
NB: Je kan niet een regel maken met een tijdsbestek van meer dan 59 uur.
Je kan deze regel ook gebruiken om DoS (Denial of Service) aanvallen tegen te gaan, door een overvloed aan pakketjes tegen te houden.
Syn-flood bescherming:
# iptables -A FORWARD -p tcp --syn -m limit --limit 1/s -j ACCEPT
Furtive port scanner:
# iptables -A FORWARD -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s -j ACCEPT
Ping of death:
# iptables -A FORWARD -p icmp --icmp-type echo-request -m limit --limit 1/s -j ACCEPT
Hoe dit werkt laat de volgende grafiek zien:
snelheid (pkt/s)
^ .---.
| / DoS \
| / \
Rand van DoS-|.....:.........\.......................
= (limit * | /: \
limit-burst) | / : \ .-.
| / : \ / \
| / : \ / \
Eide van DoS-|/....:..............:.../.......\..../.
= limit | : :`-' `--'
-------------+-----+--------------+------------------> tijd (s)
RESULTAAT=> Geldt | Geldt niet | Geldt
De volgende grafiek is van een grens van één pakketje per seconde, met een `burst' van vijf pakketjes. Pakketjes komen binnen met vier per seconde, drie seconden lang. Vervolgens nog eens na weer drie seconden:
<--Flood 1--> <---Flood 2--->
Total ^ Line __-- YNNN
Packets| Rate __-- YNNN
| mum __-- YNNN
10 | Maxi __-- Y
| __-- Y
| __-- Y
| __-- YNNN
|- YNNN
5 | Y
| Y Key: Y -> Matched Rule
| Y N -> Didn't Match Rule
| Y
|Y
0 +--------------------------------------------------> Time (seconds)
0 1 2 3 4 5 6 7 8 9 10 11 12
Je ziet hier dat de eerste vijf pakketjes sneller binnenkomen dan één per seconde en ook doorgelaten worden. Dan pas begint de grens te gelden. De volgende pakketjes zullen dus slechts met één pakketje per seconde doorgelaten worden. Na de pauze kunnen er weer meer pakketjes doorgelaten worden, totdat de grens weer gaat gelden.
Deze module zorgt ervoor dat je de eigenaar van het pakketje kan laten meetellen in een regel. Het werkt alleen in de OUTPUT reeks, en sommige pakketjes hebben geen eigenaar.
Geldt als het pakketje gemaakt werd door deze gebruiker.
Geldt als het pakketje gemaakt werd door een gebruiker in deze groep.
Geldt als het pakketje gemaakt werd door dit programma.
Geldt als het pakketje gemaakt werd door een programma in een sessie groep.
Deze module kijkt of de pakketjes wel geldig zijn en verschaft geen extra opties. Het zou niet gebruikt moeten worden om de veiligheid van een computer te verhogen.
De 'state' uitbreiding stelt je in staat om regels te maken op basis van wat van een pakketje bekend is in verband met connectie tracking. Connectie tracking wordt gerealiseerd door de `ip_conntrack' module. Deze uitbreiding is makkelijk als je wilt weten of een pakketje deel uitmaakt van een bestaande connectie of niet. Het wordt aangeraden deze optie te gebruiken, zodat je geen pakketjes doorlaat die een ander doel hebben dan een connectie te openen.
Je gebruikt deze uitbreiding met de optie `-m state' en het levert een extra `--state' optie, die gevolgd wordt door een reeks toestanden (states) van de pakketjes, gescheiden door komma's. De toestanden die beschikbaar zijn:
Dit pakketje maakt een nieuwe verbinding.
Dit pakketje behoort tot een bestaande verbinding (d.w.z. een antwoord-pakketje, of een pakketje op een connectie waar al verkeer is geweest).
Een pakketje wat te maken heeft, maar niet deel uitmaakt van een bestaande connectie. Zulke pakketjes zijn ICMP error pakketjes of pakketjes deel uitmakend van een FTP connectie.
Van dit pakketje kon niet uitgemaakt worden waar het bij hoort. Dit kan voorkomen als je geen vrij geheugen meer hebt of als je ICMP error pakketjes krijgt die niets te maken hebben met een bestaande connectie. Zulke pakketjes kunnen normaal gesproken tegen gehouden worden.
Nu we weten hoe we een pakketje kunnen specificeren, kunnen we iets doen met zo'n pakketje. Wat er moet gebeuren met een pakketje, heet het doel (target).
Er zijn twee simpele doelen al ingebouwd: DROP en ACCEPT. Met DROP wordt het pakketje tegengehouden. Met ACCEPT wordt het pakketje gewoon doorgelaten. Als een pakketje een doel heeft bereikt (DROP, ACCEPT of een ander doel) doorloopt het de resterende regels niet meer maar wordt het doel gelijk afgehandeld.
Er zijn twee soorten doelen behalve de bovenstaande: uitbreidingen en gebruikersreeksen.
Een van de kenmerken waar iptables zijn kracht vandaan haalt is dat het de gebruiker in staat stelt om zijn eigen reeksen te maken. Behalve de ingebouwde reeksen (INPUT, FORWARD en OUTPUT) kan je dus nog meer reeksen maken, die naar elkaar kunnen verwijzen en die ook weer regels bevatten. Meestal zijn de namen van gebruikersreeksen in kleine letters, om ze te kunnen onderscheiden van de ingebouwde regels.
Als een pakketje overeenkomt met een bepaalde regel en die regel verwijst naar een andere reeks, dan wordt die reeks doorlopen. Bepaald die reeks niet wat er met het pakketje gebeuren moet, dan wordt de volgende regel in de vorige reeks uitgevoerd.
In de mooie ASCII art tekening zie je twee reeksen: INPUT en
test.
`INPUT' `test'
----------------------------- ----------------------------
| Regel1: -p ICMP -j DROP | | Regel1: -s 192.168.1.1 |
|---------------------------| |---------------------------|
| Regel2: -p TCP -j test | | Regel2: -d 192.168.1.1 |
|---------------------------| -----------------------------
| Regel3: -p UDP -j DROP |
-----------------------------
Zoals je ziet verwijst regel 2 naar de reeks `test'. Stel dat er nu een
pakketje binnenkomt vanaf 192.168.1.1, dat gaat naar 1.2.3.4. Het komt binnen
in de INPUT reeks en er wordt naar de eerste regel gekeken. Aangezien
dit pakketje geen ICMP pakketje is, wordt de tweede regel bekeken. Deze geldt
wel voor dit pakketje, dus wordt het doel uitgevoerd: reeks test wordt
uitgevoerd op dit pakketje. Regel 1 geldt voor dit pakketje, maar er is hier
geen doel opgegeven. Er gebeurt dus niets met dit pakketje. Regel 2 geldt niet
en we zijn aan het einde van deze reeks.
Er wordt meer verder gegaan bij regel 3 van de INPUT reeks.
De weg van het pakketje is dus als volgt:
v __________________________
`INPUT' | / `test' v
-------------------------|--/ ------------------------|----
| Regel1 | /| | Regel1 | |
|------------------------|/-| |-----------------------|---|
| Regel2 / | | Regel2 | |
|---------------------------| ------------------------v----
| Regel3 /--+___________________________/
-------------------------|---
v
Gebruikersreeksen kunnen verwijzen naar andere gebruikersreeksen. Als je echter heen en weer verwijst kan het voorkomen dat je pakketjes in een lus komen. Dit vergt veel processortijd en je pakketjes worden tegengehouden.
Met uitbreidingen kan je nieuwe doelen opgeven. Een doel-uitbreiding bestaat
uit een kernel module en eventueel een iptables uitbreiding. De
volgende uitbreidingen zijn beschikbaar bij netfilter:
Met deze uitbreiding kan je pakketjes loggen in je syslog. Het biedt de volgende opties:
wordt gevolgd door een nummer of een naam, zoals `debug', `info', `notice', `warning', `err', `crit', `alert' of `emerg'. Deze namen komen overeen met de nummers 7 tot en met 0. De handleiding van syslog.conf geeft aan wat deze namen betekenen.
wordt gevolgd door een regel van maximaal 29 letters. Deze regel komt vóór de eigenlijke boodschap in het logbestand, zodat je de boodschap makkelijk kan terugvinden.
Het wordt aangeraden om de limit-uitbreiding te gebruiken in combinatie met deze module, zodat je niet je log (en misschien je harde schijf) vol zet als je opeens veel pakketjes krijgt.
Deze module werkt hetzelfde als `DROP', alleen wordt de afzender op de hoogte gesteld dat het pakketje is tegengehouden door middel van een `port unreachable' (onbereikbaar) ICMP pakketje. Zo'n pakketje wordt niet verzonden als
REJECT heeft ook een extra optie `--reject-with' waarmee je kan bepalen welk pakketje teruggestuurd moet worden. Zie de handleiding voor meer informatie hierover.
Er zijn twee ingebouwde doelen die een speciale functie hebben:
RETURN en QUEUE.
RETURN beeindigd een gebruikersreeks. Het heeft hetzelfde effect
als aan het einde van de reeks komen, namelijk dat naar de oorspronkelijke
reeks wordt teruggekeerd en dat de volgende regel uitgevoerd wordt.
Als dit in een ingebouwde reeks wordt gebruikt, wordt het beleid van die
reeks uitgevoerd op het pakketje.
QUEUE bewaart het pakketje om later door een programma verwerkt te
worden. Dit is alleen nuttig als:
is a special target, which queues the packet for userspace processing. For this to be useful, two further components are required:
Als er geen programma is wat op de pakketjes wacht, dan worden ze
tegengehouden. Om zo'n programma te schrijven kan je de libipq API
gebruiken. Het bestand /proc/net/ip_queue geeft de status van
ip_queue aan en het bestand /proc/sys/net/ipv4/ip_queue_maxlen geeft
de maximale lengte van de queue (normaal 1024).
Als je veel regels hebt kan het wel eens een chaos worden als je ze allemaal in één reeks zet. Daarom is het handig om zelf reeksen te maken. Je kan je eigen reeksen noemen zoals je wilt, maar aangeraden wordt kleine letters te gebruiken om ze te kunnen onderscheiden van ingebouwde reeksen, die namen in hoofdletters hebben. De namen van reeksen kunnen niet langer zijn dan 31 letters.
Hier volgt een voorbeeld van hoe je een reeks kan maken met een hele originele
naam: test:
# iptables -N test
#
Dat is alles. Nu heb je een reeks zonder regels erin, die test heet.
Een reeks verwijderen is ook simpel, maar kan alleen als de reeks helemaal geen regels meer bevat. Er moeten ook geen verwijzingen meer zijn naar de reeks die je wilt verwijderen. Je verwijdert een regel met `-X' of `--delete-chain':
# iptables -X test
#
Als je de naam van de reeks weg laat, worden alle gebruikersreeksen verwijdert.
Er is een simpele manier om alle regels uit een reeks te verwijderen, namelijk met de `-F' of `--flush' optie:
# iptables -F FORWARD
#
Als je geen reeks opgeeft, worden alle reeksen leeg gemaakt.
Om alle regels in een reeks te bekijken gebruik je de `-L' optie, of de `--list' optie.
Bij gebruikersreeksen zie je een `refcnt' staan. Dit is het aantal verwijzingen naar deze reeks. Dit moet nul zijn voordat de reeks kan worden verwijdert.
Je kan nog drie extra opties gebruiken naast `-L'. Met de `-n' optie kan je ervoor zorgen dat IP adressen niet omgezet worden naar domeinnamen. Dit is nuttig als je DNS niet goed werkt. Het opzoeken van namen zorgt dan namelijk voor grote vertragingen. Poorten worden ook weergegeven als nummers (`80') in plaats van namen (`www').
Met de `-v' optie krijg je alle pikante details te zien, zoals de interfaces en pakket tellers.
The pakket en byte tellers gebruiken achtervoegsels zoals `K' (kilo) en `M' (mega) voor 1.000 en 1.000.000. Gebruik de `-x' optie als je de hele cijfers wilt weten, zonder achtervoegsels.
Je kan een teller op nul zetten met de `-Z' of `--zero' optie.
Als je het volgende doet:
# iptables -L FORWARD
# iptables -Z FORWARD
#
Kunnen er nog pakketjes doorkomen in de tijd dat je het tweede commando aan het typen bent. Om dit te voorkomen kan je de `-L' en `-Z' opties tegelijk gebruiken, om de tellers tegelijk te lezen en op nul te zetten.
Als een pakketje aan het einde van een reeks komt, wordt het beleid uitgevoerd.
Alleen ingebouwde reeksen (INPUT, OUTPUT en FORWARD)
hebben een beleid.
Het beleid kan ACCEPT (doorlaten) of DROP (tegenhouden) zijn.
# iptables -P FORWARD DROP
#
FORWARD in op DROP.