De minimale set Iptables-regels voor typische taken. Iptables: netwerkbeveiliging en pakketfiltering

Groetjes aan iedereen! In vervolg publiceer ik dit praktische artikel op: Linux-netwerkfilter... In het artikel zal ik overwegen typische voorbeelden van implementatie van iptables-regels in Linux, en overweeg ook de manieren de gemaakte iptables-configuratie opslaan.

Netfilter / iptables instellen voor een werkstation

Laten we beginnen met een elementaire taak - implementatie van een Linux firewall op een desktop... In de meeste gevallen is het niet dringend nodig om een ​​firewall te gebruiken op desktop Linux-distributies. op dergelijke distributies zijn alle services die naar netwerkpoorten luisteren niet actief, maar ter preventie is het niet overbodig om bescherming te organiseren. Want ook de kern is niet immuun voor gaten. Dus we hebben Linux, met eth0, het maakt niet uit via DHCP of statisch ...

Voor instellingen: firewall Ik probeer me aan het volgende beleid te houden: alles verbieden, en dan wat mag. Dus dat doen we in dit geval. Als je een pas geïnstalleerd systeem hebt en je hebt nog niet geprobeerd er een netwerkfilter op te configureren, dan zien de regels er als volgt uit:

Netfilter: ~ # iptables -L Chain INPUT (beleid ACCEPT) doel prot opt ​​bronbestemming Chain FORWARD (beleid ACCEPT) doel prot opt ​​bronbestemming Chain OUTPUT (beleid ACCEPT) doel prot opt ​​bronbestemming

Dit betekent dat het standaardbeleid voor: filtertabellen in alle ketens - AANVAARDEN en er zijn geen andere regels die iets verbieden. Dus laten we eerst ALLES en pakketten verbieden!(probeer dit niet op afstand te doen, je raakt direct de toegang kwijt):

Netfilter: ~ # iptables -P INPUT DROP netfilter: ~ # iptables -P OUTPUT DROP netfilter: ~ # iptables -P FORWARD DROP

Met deze commando's zetten we LATEN VALLEN standaard. Dit betekent dat elk pakket dat niet expliciet een regel heeft die het toestaat, automatisch wordt verwijderd. Aangezien we nog geen enkele regel hebben ingesteld, worden alle pakketten die naar uw computer komen, evenals die welke u naar het netwerk probeert te sturen, geweigerd. Als demo kun je proberen je computer te pingen via de loopback-interface:

Netfilter: ~ # ping -c2 127.0.0.1 PING 127.0.0.1 (127.0.0.1) 56 (84) bytes aan gegevens. ping: sendmsg: bewerking niet toegestaan ​​ping: sendmsg: bewerking niet toegestaan ​​--- localhost ping-statistieken --- 2 pakketten verzonden, 0 ontvangen, 100% pakketverlies, tijd 1004ms

In feite is dit een volledig niet-functionerend netwerk en dit is niet erg goed, omdat sommige daemons gebruiken een loopback-interface om met elkaar uit te wisselen, die na de uitgevoerde acties niet meer werkt. Dit kan de werking van dergelijke diensten verstoren. Zorg er daarom in de eerste plaats voor dat de verzending van pakketten mogelijk maken via de inkomende loopback-interface en uitgaande loopback-interface in de INPUT-tabellen(om de verzonden pakketten te kunnen ontvangen) en UITGANG(voor de mogelijkheid om pakketten te verzenden) respectievelijk. Dus doe zeker:

Netfilter: ~ # iptables -A INPUT -i lo -j ACCEPTEREN netfilter: ~ # iptables -A OUTPUT -o lo -j ACCEPT

Daarna zal pingen naar localhost werken:

Netfilter: ~ # ping -c1 127.0.0.1 PING 127.0.0.1 (127.0.0.1) 56 (84) bytes aan gegevens. 64 bytes van 127.0.0.1 (127.0.0.1): icmp_seq = 1 ttl = 64 tijd = 0,116 ms --- 127.0.0.1 ping-statistieken --- 1 pakketten verzonden, 1 ontvangen, 0% pakketverlies, tijd 116 ms rtt min / gem / max / mdev = 0,116 / 0,116 / 0,116 / 0,116 ms

Als je niet al te fanatiek bent in het opzetten van een firewall, dan kun je het ICMP-protocol inschakelen:

Netfilter: ~ # iptables -A INPUT -p icmp -j ACCEPTEREN netfilter: ~ # iptables -A OUTPUT -p icmp -j ACCEPT

Het is veiliger om het volgende vergelijkbare iptables-commando op te geven:

Netfilter: ~ # iptables -A INPUT -p icmp --icmp-type 0 -j ACCEPT netfilter: ~ # iptables -A INPUT -p icmp --icmp-type 8 -j ACCEPT netfilter: ~ # iptables -A OUTPUT -p icmp -j ACCEPTEREN

Met deze opdracht worden de pakkettypen ICMP Echo Request en Echo Reply ingeschakeld, wat de beveiliging verbetert.

Wetende dat onze computer niet geïnfecteerd is (is dat zo?) En hij brengt alleen veilige uitgaande verbindingen tot stand. En ook, wetende dat beveiligde verbindingen verbindingen zijn van de zogenaamde. een kortstondig poortbereik, dat door de kernel in een bestand wordt ingesteld / proc / sys / net / ipv4 / ip_local_port_range, kan uitgaande verbindingen toestaan vanaf deze beveiligde poorten:

Netfilter: ~ # cat / proc / sys / net / ipv4 / ip_local_port_range 32768 61000 netfilter: ~ # iptables -A OUTPUT -p TCP --sport 32768: 61000 -j ACCEPT netfilter: ~ # iptables -A OUTPUT -p UDP - sport 32768: 61000 -j ACCEPTEREN

Als de aanpak om uitgaande pakketten te beperken niet paranoïde is, dan kan het beperkt worden tot één commando iptables die alle uithardende verbindingen toestaan voor alle protocollen en poorten:

Netfilter: ~ # iptables -A OUTPUT -j ACCEPT netfilter: ~ # # of stel gewoon het standaard ACCEPT-beleid in voor de netfilter OUTPUT-keten: ~ # iptables -P OUTPUT ACCEPT

Verder, wetende dat netwerkverbindingen in netfilter 4 toestanden hebben ( NIEUWE,VASTGESTELD,GERELATEERD enINVALIDE) en nieuwe uitgaande verbindingen vanaf de lokale computer (met de NIEUWE status) zijn toegestaan ​​in de laatste twee iptables-opdrachten, dat de reeds tot stand gebrachte verbindingen en extra verbindingen een status hebben GEVESTIGD enVERWANT, dienovereenkomstig, en ook wetende waardoor ze naar het lokale systeem komen, kun je alleen die TCP- en UDP-pakketten toestaan ​​die door lokale applicaties zijn aangevraagd om onze computer te bereiken:

Netfilter: ~ # iptables -A INPUT -p TCP -m status --state VASTGESTELD, GERELATEERD -j ACCEPTEREN netfilter: ~ # iptables -A INPUT -p UDP -m staat --state GEVESTIGD, GERELATEERD -j ACCEPTEREN

Dat is alles! Als er nog steeds een netwerkservice op het bureaublad actief is, moet u de juiste regels voor inkomende en uitgaande verbindingen toevoegen. Bijvoorbeeld, om de ssh-server te laten werken die verzoeken accepteert en verzendt op TCP-poort 22, moet u het volgende toevoegen: iptables regels:

Netfilter: ~ # iptables -A INPUT -i eth0 -p TCP --dport 22 -j ACCEPTEREN netfilter: ~ # iptables -A OUTPUT -o eth0 -p TCP --sport 22 -j ACCEPT

Die. voor elke service moet u één regel toevoegen aan de INPUT- en OUTPUT-ketens, waardoor u respectievelijk pakketten kunt ontvangen en verzenden via deze poort voor een specifieke netwerkinterface (als er geen interface is gespecificeerd, is het toegestaan ​​om pakketten te ontvangen / verzenden op elke koppel).

Netfilter / iptables configureren om meerdere clients met dezelfde verbinding te verbinden.

Laten we nu eens kijken naar onze Linux als gateway voor een lokaal netwerk naar het externe internet... Laten we doen alsof eth0-interface is verbonden met internet en heeft IP 198.166.0.200, en eth1-interface is verbonden met het lokale netwerk en heeft een IP van 10.0.0.1. Standaard in de Linux-kernel pakketten doorsturen via de FORWARD-keten(pakketten die niet gericht zijn op het lokale systeem) is uitgeschakeld. Om deze functie in te schakelen, moet u de waarde 1 in het bestand instellen :

Netfilter: ~ # echo 1> / proc / sys / net / ipv4 / ip_forward

Tot pakket doorsturen opgeslagen na opnieuw opstarten, het is nodig in het bestand /etc/sysctl.conf verwijder commentaar (of voeg gewoon toe) de regel net.ipv4.ip_forward = 1.

We hebben dus een extern adres (198.166.0.200), in het lokale netwerk zijn er een aantal hypothetische clients die verzoeken hebben en verzenden naar het externe netwerk. Als deze clients verzoeken naar het externe netwerk sturen via de gateway "as is", zonder conversie, dan kan de externe server ze niet beantwoorden, omdat het retouradres is de ontvanger van het "lokale netwerk". Om dit schema correct te laten werken, is het noodzakelijk om het adres van de afzender te vervangen door het externe adres van de Linux-gateway. Dit wordt bereikt door (masquerading) in, in.

Netfilter: ~ # iptables -A FORWARD -m conntrack --ctstate VASTGESTELD, GERELATEERD -j ACCEPT netfilter: ~ # iptables -A FORWARD -m conntrack --ctstate NIEUW -i eth1 -s 10.0.0.1/24 -j ACCEPT netfilter: ~ # iptables -P FORWARD DROP netfilter: ~ # iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

Dus, in volgorde van boven naar beneden, lossen we reeds bestaande verbindingen op in ketting VOORUIT, filtertabel, dan laten we nieuwe verbindingen tot stand brengen in ketting VOORUIT, filtertabel die afkomstig was van de eth1-interface en van het 10.0.0.1/24-netwerk. Alle andere pakketten die door gaan ketting VOORUIT- weggooien. Vervolgens voeren we maskering uit (vervanging van het pakketafzenderadres in de headers) van alle pakketten die uitgaan van de eth0-interface.

Opmerking. Er is een algemene aanbeveling: gebruik de -j MASQUERADE regel voor interfaces met dynamisch verkregen IP (bijvoorbeeld via DHCP van de provider). Met een statisch IP-adres kan -j MASQUERADE worden vervangen door het equivalente -j SNAT -to-source IP_eth0. Bovendien kan SNAT de tot stand gebrachte verbindingen "onthouden" wanneer de interface korte tijd niet beschikbaar is. Vergelijking van MASQUERADE en SNAT in de tabel:

Naast deze regels kunt u ook regels toevoegen voor het filteren van pakketten die bestemd zijn voor de lokale host - zoals beschreven in. Dat wil zeggen, voeg regels toe voor het blokkeren en toestaan ​​van inkomende en uitgaande verbindingen:

Netfilter: ~ # iptables -P INPUT DROP netfilter: ~ # iptables -P OUTPUT DROP netfilter: ~ # iptables -A INPUT -i lo -j ACCEPT netfilter: ~ # iptables -A OUTPUT -olo -j ACCEPT netfilter: ~ # iptables -A INPUT -p icmp --icmp-type 0 -j ACCEPT netfilter: ~ # iptables -A INPUT -p icmp --icmp-type 8 -j ACCEPT netfilter: ~ # iptables -A OUTPUT -p icmp -j ACCEPT netfilter: ~ # cat / proc / sys / net / ipv4 / ip_local_port_range 32768 61000 netfilter: ~ # iptables -A OUTPUT -p TCP --sport 32768: 61000 -j ACCEPT netfilter: ~ # iptables -A OUTPUT -p UDP - sport 32768: 61000 -j ACCEPT netfilter: ~ # iptables -A INPUT -p TCP -m staat --state GEVESTIGD, GERELATEERD -j ACCEPT netfilter: ~ # iptables -A INPUT -p UDP -m staat --state VASTGESTELD, GERELATEERD - j ACCEPTEREN

Als gevolg hiervan, als een van de hosts op het lokale netwerk, bijvoorbeeld 10.0.0.2, probeert contact te maken met een van de internethosts, bijvoorbeeld 93.158.134.3 (ya.ru), wanneer hun oorspronkelijke adres wordt vervangen door het externe gateway-adres in de POSTROUTING-tabelketen nat, dat wil zeggen, het uitgaande IP 10.0.0.2 wordt vervangen door 198.166.0.200. Vanuit het oogpunt van de externe host (ya.ru), zal het lijken alsof de gateway zelf er rechtstreeks mee communiceert. Wanneer de externe host een responsoverdracht van gegevens start, zal deze deze exact naar de gateway adresseren, dat wil zeggen 198.166.0.200. Op de gateway wordt het bestemmingsadres van deze pakketten echter gewijzigd in 10.0.0.2, waarna de pakketten worden verzonden naar de echte ontvanger op het lokale netwerk. Voor zo'n omgekeerde transformatie hoeven geen extra regels te worden gespecificeerd - dit zal hetzelfde doen MASQUERADE operatie, die onthoudt welke host van het lokale netwerk het verzoek heeft verzonden en welke host het ontvangen antwoord moet retourneren.

Opmerking: bij voorkeur stilzwijgend aanvaard, voor alle iptables-opdrachten duidelijke ketens waaraan regels worden toegevoegd:

Netfilter: ~ # iptables -F CHAINNAME

Toegang verlenen tot services op de gateway

Stel dat er een bepaalde dienst draait op onze gateway, die zou moeten reageren op verzoeken van internet. Laten we zeggen dat het werkt op een of andere TCP-poort nn. Om toegang tot deze service te verlenen, moet u de filtertabel in de INPUT-keten wijzigen (om netwerkpakketten te kunnen ontvangen die zijn geadresseerd aan de lokale service) en de filtertabel in de OUTPUT-keten (om antwoorden op inkomende verzoeken mogelijk te maken).

We hebben er dus een die pakketten vermomt (vervangt het adres van de afzender door de uitgaande) pakketten naar het externe netwerk. En het maakt het mogelijk om alle gevestigde verbindingen te accepteren. Het verlenen van toegang tot de dienst zal worden uitgevoerd met behulp van de volgende toestemmingsregels:

Netfilter: ~ # iptables -A INPUT -p TCP --dport nn -j ACCEPTEREN netfilter: ~ # iptables -A OUTPUT -p TCP --sport nn -j ACCEPT

Deze regels staan ​​inkomende tcp-verbindingen toe naar poort nn en uitgaande tcp-verbindingen vanaf poort nn. Daarnaast kunt u aanvullende beperkende parameters toevoegen, bijvoorbeeld alleen inkomende verbindingen toestaan ​​vanaf de externe eth0-interface (sleutel -ik eth0) enzovoort.

Toegang verlenen tot diensten op het lokale netwerk

Stel dat we een soort host hebben met IP X.Y.Z.1 op ons lokale netwerk, die moet reageren op netwerkverzoeken van het externe netwerk op TCP-poort xxx. Om ervoor te zorgen dat de service van het lokale netwerk correct reageert wanneer een externe client toegang krijgt tot een extern IP-adres naar poort xxx, is het noodzakelijk om verzoeken die naar de externe IP-poort xxx komen naar de corresponderende host in het lokale netwerk te sturen. Dit wordt bereikt door het bestemmingsadres te wijzigen in het pakket dat aankomt op de opgegeven poort. Deze actie wordt DNAT genoemd en wordt toegepast op de PREROUTING-keten in de nat-tabel. En laat ook de passage van deze pakketten in de FORWARD-keten in de filtertabel toe.

Nogmaals, laten we het pad volgen. We hebben er dus een die pakketten vermomt (vervangt het adres van de afzender door de uitgaande) pakketten naar het externe netwerk. En het maakt het mogelijk om alle gevestigde verbindingen te accepteren. Het verlenen van toegang tot de dienst zal worden uitgevoerd met behulp van de volgende toestemmingsregels:

Netfilter: ~ # iptables -t nat -A PREROUTING -p tcp -d 198.166.0.200 --dport xxx -j DNAT --to-destination XYZ1 netfilter: ~ # iptables -A FORWARD -i eth0 -p tcp -d XYZ 1 --dport xxx -j ACCEPTEREN

De ingevoerde regels opslaan bij opnieuw opstarten

Alle regels die in de console zijn ingevoerd - na het opnieuw opstarten van het besturingssysteem worden ze teruggezet naar hun oorspronkelijke staat (lees - verwijderd). Tot sla alle ingevoerde iptables-opdrachten op, zijn er verschillende manieren. Een daarvan is bijvoorbeeld om alle firewallregels in het init-bestand op te geven. Maar deze methode heeft een belangrijk nadeel: de hele periode vanaf het begin van het netwerksubsysteem, tot het begin van de laatste service en vervolgens het rc.local-script van SystemV, zal het besturingssysteem niet worden beschermd. Stel je een situatie voor, bijvoorbeeld als een service (bijv. NFS) de laatste is die start, en wanneer deze start, crasht deze zelfs voordat het rc.local-script wordt uitgevoerd. Daarom zal rc.local nooit starten en verandert ons systeem in één groot gat.

Daarom zou het beste idee zijn: netfilter / iptables-regels initialiseren tijdens het laden. Debian heeft hiervoor een geweldig hulpmiddel - de directory /etc/network/if-up.d/, waarin u scripts kunt plaatsen die worden gestart wanneer het netwerk wordt gestart. En er zijn ook opdrachten iptables-save en iptables-herstel die dump netfilter-regels van kernel naar kernel dumpen en dienovereenkomstig regels van kernel naar kernel herstellen.

Dus, het algoritme voor het opslaan van iptables is ongeveer het volgende::

• We configureren de firewall voor onze behoeften met behulp van
• maak een dump van de gemaakte regels met behulp van de opdracht iptables-save> /etc/iptables.rules
• creëren script importeren dump aangemaakt bij het opstarten van het netwerk (in de /etc/network/if-up.d/ directory) en vergeet niet om het uitvoerbaar te maken:

Dump van regels ontvangen met het iptables-save commando heeft een tekstformaat, dus geschikt voor bewerking. De syntaxis voor de opdracht iptables-save is als volgt::

# Gegenereerd door iptables-save v1.4.5 op za 24 dec 22:35:13 2011 * filter: INPUT ACCEPT: FORWARD ACCEPT ....... # comment -A INPUT -i lo -j ACCEPT -A INPUT! -i lo -d 127.0.0.0/8 -j REJECT ........... -A FORWARD -j REJECT COMMIT # Voltooid op za 24 december 22:35:13 2011 # Gegenereerd door iptables-save v1 .4.5 op za 24 dec 22:35:13 2011 * raw ...... COMMIT

Regels die beginnen met # - opmerkingen, regels aan * is de naam van de tabellen, tussen de naam van de tabel en het woord VERBINDEN bevat de parameters die zijn doorgegeven aan de opdracht iptables. COMMIT-parameter- geeft de voltooiing van de parameters voor de bovenstaande tabel aan. Regels die beginnen met een dubbele punt geven de tekenreeksen aan die deze tabel bevatten in de indeling:

: kettingbeleid [pakketten: bytes]

waar ketting- de naam van de ketting, politiek- het standaardketenbeleid voor deze tabel, en vervolgens de pakket- en bytetellers op het moment van uitvoering van de opdracht.

In RedHat iptables commando opslagfuncties uitgevoerd bij opstarten en afsluiten van het netwerk voert het bestand uit / etc / sysconfig / iptables... En dit bestand wordt beheerd door de iptables-daemon.

Als een andere optie om de regels op te slaan, kunt u overwegen de parameter te gebruiken omhoog in bestand / etc / netwerk / interfaces met een argument in de vorm van een bestand dat iptables-opdrachten opslaat die de nodige regels specificeren.

Resultaat

Genoeg voor vandaag. Meer complexe implementaties van de firewall zal ik zeker in de volgende artikelen publiceren.

Met vriendelijke groet, Mc Sim!

Dus vandaag zullen we uitzoeken wat voor soort beest deze IPTables is en hoe ermee om te gaan, het te verslaan en te beteugelen? :)

IPTables is een opdrachtregelprogramma dat de standaardinterface is voor het besturen van de werking van een firewall (firewall of firewall) NETFilter voor Linux-kernels, vanaf versie 2.4. Superuser-rechten (root) zijn vereist om het hulpprogramma IPTables te gebruiken.

Soms verwijst IPTables naar de NETFilter-firewall zelf. Met zijn hulp kunt u vrij flexibel beheren (in dit geval de verwerking van pakketten die naar ons toe komen of van ons uitgaan).

Zo kun je de ene computer de toegang tot internet ontzeggen, een andere alleen toegang tot websites, de derde kan een vooraf bepaalde poort worden doorgestuurd (toewijzen) en “verdachte” pakketten kunnen teruggestuurd worden naar de afzender (zelfs als deze kapot gaat). zelf). U kunt de service-informatie van IP-pakketten "on the fly" (afzender, ontvanger, TTL, enz.) En nog veel meer wijzigen, wat u zich gewoon niet kunt voorstellen.

Om te beginnen, wat u moet weten over firewalls is dat ze zijn ontworpen voor bescherming, dus u moet er rekening mee houden dat de laatste regel ( beleid) moet "de rest verbieden" zijn. Ten tweede, maar daarom niet minder belangrijk, bewerk regels of Telnet altijd zorgvuldig.

Gevallen waarin de regels voor afstandsbediening werden geconfigureerd en na het toepassen van de regels, een onoplettende beheerder werd "afgesneden" van de server, zijn niet geïsoleerd! En het is goed als de server op een steenworp afstand is, maar wat als hij ergens in het verre koninkrijk is?

Hoe een firewall werkt

Wanneer een pakket bij onze firewall aankomt, wordt het eerst geraakt, onderschept door de juiste driver en vervolgens doorgegeven aan de kernel. Vervolgens gaat het pakket door een reeks tabellen, en vervolgens wordt het doorgegeven aan een lokale toepassing of doorgestuurd naar een andere machine.

De volgorde van het pakket wordt weergegeven in de onderstaande tabel:

Zoals u kunt zien, doorloopt het pakket verschillende fasen voordat het wordt doorgegeven. In elke fase kan het pakket worden gestopt, of het nu de iptables-keten is of iets anders, maar we zijn vooral geïnteresseerd in iptables.

Merk op dat er geen interface-specifieke chaining of iets dergelijks is. ALLE pakketten die door onze firewall-router gaan, gaan door de FORWARD-keten. Gebruik de INPUT-keten niet om transitpakketten te filteren, ze gaan daar gewoon niet heen. Alleen gegevens die voor dezelfde host zijn bedoeld, gaan door deze keten.

Iptables-regels

Ik zal een voorbeeld geven van een deel van mijn routerconfiguratie: vlan332 is de interface waarmee ik toegang heb tot internet, vlan333 is toegang tot het lokale netwerk van de provider en 172.30.2.5 is mijn computer.

#NAT
iptables -t nat -A POSTROUTING -o vlan332 -j MASQUERADE
iptables -t nat -A POSTROUTING -o vlan333 -j MASQUERADE

#Torrent
iptables -A PREROUTING -t nat -p tcp --dport 9000 -i vlan332 -j DNAT --to 172.30.2.5

#Open poort
iptables -A INPUT -p tcp --dport 53 -j ACCEPTEREN #DNS TCP
iptables -A INPUT -p udp --dport 53 -j ACCEPTEREN #DNS UDP
iptables -A INPUT -p tcp --dport 80 -j ACCEPTEREN #WEB-server

# Alle andere inkomende "drop" (verwijderen)
iptables -A INPUT -i vlan332 -j DROP

Wat betekent dit allemaal? Allereerst heb ik voor het gemak van het lezen de configuratie verdeeld in "secties" met opmerkingen, d.w.z. in één sectie zijn er regels voor NAT, in een andere - port forwarding (PAT), in de derde - staan ​​we serverpoorten toe, enz.

Overweeg de eerste en tweede regel (ze verschillen alleen in netwerkinterfaces):

iptables -t nat -A POSTROUTING -o vlan332 -j MASQUERADE

Op basis hiervan voegen we een nieuwe regel toe voor de postrouting-keten (-A POSTROUTING) aan de nat-tabel (-t nat), die de laatste regel in de keten zal zijn op het moment dat de opdracht wordt uitgevoerd (dwz aan het einde ). De regel wordt toegepast op de uitgaande interface vlan332 (-o vlan332) en wordt doorgegeven aan MASQUERADE (-j MASQUERADE) die NAT's.

In menselijke termen moet alles wat de vlan332-interface verlaat achter NAT worden verborgen.Dit betekent dat bij het verlaten van onze router onze server wordt aangegeven door het adres van de afzender, en niet de eindcomputer van de gebruiker van waaruit het verzoek is verzonden. op het verzoek, wordt de omgekeerde procedure uitgevoerd en wordt het pakket doorgestuurd naar de oorspronkelijke afzender, waarvoor dit in detail wordt beschreven in het artikel over NAT.

Laten we verder gaan met de volgende groep regels, namelijk de sectie gemarkeerd als "torrent". Deze sectie bevat de regels voor port forwarding (PAT - Port Address Translation), d.w.z. zodat u vanaf de internetkant verbinding kunt maken met de poort op de computer achter onze router. Zonder dit zullen veel applicaties niet goed kunnen werken, bijvoorbeeld torrent-netwerken voor het delen van bestanden, DC ++ en sommige applicaties die inkomende verbindingen van internet vereisen. Laten we de regel analyseren aan de hand van het voorbeeld van port forwarding (toewijzing) voor een Torrent-client

iptables -A PREROUTING -t nat -p tcp --dport 9000 -i vlan332 -j DNAT --to 172.30.2.5

Net als in de vorige regel specificeren we de tabel en keten (-A PREROUTING -t nat), we geven het toegestane protocoltype aan. In de huidige TCP-regel (-p tcp) (in een andere UDP-regel, hoewel ze in één regel kunnen worden gespecificeerd, is het me helaas niet gelukt, zelfs niet met de officiële literatuur en heb ik nog geen oplossing gevonden).

Bestemmingspoort 9000 (--dport 9000), inkomende vlan332-interface. Met de actie DNAT (-j DNAT) geven we aan dat u het adres van de ontvanger moet wijzigen in 172.30.2.5 (--to 172.30.2.5), d.w.z. - onze computer. Het blijkt: stuur alle inkomende TCP-verbindingen om naar poort 9000 naar IP 172.30.2.5.

iptables -A INPUT -p tcp --dport 53 -j ACCEPTEREN #DNS TCP

We geven de INPUT-keten, het TCP-protocol, poortnummer 53 (gebruikt voor de werking van DNS-services) en de actie aan - toestaan... Mogelijk merkt u dat UDP wordt gebruikt voor DNS-query's en dat dit correct is. Om informatie over zones (domeinen) over te dragen, wordt TCP gebruikt, en aangezien mijn server de primaire is voor verschillende zones, heb ik toegang via TCP toegestaan.

De laatste regel, zoals ik hierboven al zei, zou moeten zijn om al het andere te verbieden dat niet onder de filters viel. ik schreef iptables -A INPUT -i vlan332 -j DROP die. verwijder alle inkomende pakketten naar de vlan332-interface.

Aangezien deze firewall geen permanente configuratie heeft, moeten de regels bij het opnieuw opstarten handmatig worden ingevoerd. Dit maakt niet uit, aangezien er shell-scripts zijn (analoog aan bat- en cmd-bestanden in Windows) en wanneer ze worden uitgevoerd, zullen ze de erin geschreven opdrachten uitvoeren.

Om dit te doen, maakt u een bestand aan in de etc-map met de naam firewall.sh met het commando nano /etс/firewall.sh, d.w.z. laten we het direct in de editor openen. Laten we alle regels invoeren die we daar nodig hebben en deze opslaan door op Ctrl + X te drukken.

Hier zijn enkele regels van de werkende configuratie die u misschien nuttig vindt in uw dagelijks gebruik. De eerste regel (#! / Bin / sh) is vereist, omdat deze aangeeft hoe deze instructies moeten worden geïnterpreteerd.

#! / bin / sh
PATH = / usr / sbin: / sbin: / bin: / usr / bin

# Verwijder alle bestaande regels van alle tabellen en ketens
iptables -F
iptables -t nat -F
iptables -t mangel -F
iptables -X

# Sta al het verkeer toe
iptables -A INPUT -i lo -j ACCEPT # loopback
iptables -A INPUT -i eth0 -j ACCEPT # Interne interface naar LAN
iptables -A INPUT -i eth2 -j ACCEPT # Interne interface naar LAN 2

#NAT
iptables -t nat -A POSTROUTING -o vlan332 -j MASQUERADE # NAT inschakelen voor internet
iptables -t nat -A POSTROUTING -o vlan333 -j MASQUERADE # NAT inschakelen voor ISP (ISP-netwerk)

#PORT FORWARDING
#Torrent
iptables -A PREROUTING -t nat -p tcp --dport 9000 -i vlan332 -j DNAT --to 172.30.2.5 # Port forwarding naar IP
iptables -A PREROUTING -t nat -p udp --dport 9000 -i vlan332 -j DNAT --to 172.30.2.5

#VPN-verbindingen, PPP-verbindingen toestaan, enz.
iptables -A INPUT -p tcp -m tcp --dport 1723 -j ACCEPTEREN
iptables -A INPUT -p gre -m state --state GERELATEERD, GEVESTIGD -j ACCEPTEREN

# Open serverpoorten
iptables -A INPUT -p tcp --dport 23 -j ACCEPT # SSH-toegang toestaan

# Verwijder al het andere dat binnenkomt ("drop" - weggooien)
iptables -A INPUT -i vlan332 -j DROP

# Doorsturen inschakelen, zonder dit zal pakketroutering niet plaatsvinden
echo 1> / proc / sys / net / ipv4 / ip_forward

Daarna maken we het bestand uitvoerbaar, d.w.z.:
chmod + x /etc/firewall.sh(uitvoeren).

Om dit bestand automatisch te laten werken tijdens het laden, zullen we het pad ernaartoe schrijven in het "opstart"-bestand. Open nano /etc/rc.local en voeg de regel /etc/firewall.sh toe voordat u 0 afsluit. Als u VLAN's (virtuele interfaces en netwerken) moet gebruiken, moet u deze regel in het bestand / etc / network / schrijven interfaces als up sh / etc /firewall.sh naar de vlan-interface, bijvoorbeeld:

# VLAN naar INET
auto vlan332
iface vlan332 inet statisch
adres xxx.xxx.xxx.xxx
netmasker 255.255.255.252
# gateway xxx.xxx.xxx.xxx
vlan_raw_device eth1
omhoog sh /etc/firewall.sh

Dit is nodig omdat eerst de "autoload" zal plaatsvinden, en pas na een tijdje zullen onze VLAN-interfaces stijgen, en als er geen interface is, wordt de regel niet gemaakt.

Helaas kan ik het werk van deze geweldige firewall niet volledig beschrijven, maar er is uitstekende documentatie over in het Russisch (vertaling van de originele ontwikkelaarsgids), hier is het adres.

Het zal niet moeilijk zijn, zelfs na het lezen van een deel ervan of het instellen van een specifieke taak, om de meeste problemen op te lossen die verband houden met deze firewall en zelfschrijvende regels.

Een betrouwbare firewall is een van de belangrijkste aspecten van de bescherming van elk modern besturingssysteem. De meeste Linux-distributies bevatten verschillende firewalltools. Deze tutorial is gewijd aan een van de meest populaire - iptables.

Dus iptables is de standaard firewall die standaard bij de meeste Linux-distributies wordt geleverd (nftables wordt ontwikkeld om het te vervangen). In feite is iptables de gebruikersinterface voor het beheer van het netfiltersysteem, dat op zijn beurt de Linux-netwerkstack beheert. iptables vergelijkt elk binnenkomend pakket met een reeks vastgestelde regels en beslist vervolgens wat ermee te doen.

Ik heb het gehad over hoe iptables precies werkt. Dit artikel richt zich op praktische voorbeelden die laten zien hoe u een basisregelset voor een Ubuntu 14.04-server kunt maken.

Basis iptables-opdrachten

Deze sectie bevat basiscommando's die kunnen worden gebruikt om een ​​complexe set regels te maken en de iptables-interface als geheel te besturen.

Onthouden: iptables-opdrachten moeten worden uitgevoerd met root-rechten. Dit betekent dat u een van de volgende handelingen moet uitvoeren:

• log in als rootgebruiker;
• gebruik su of sudo -i om de rootshell uit te breiden;
• start alle opdrachten met sudo (aanbevolen op Ubuntu).

Deze handleiding past de laatste optie toe.

U moet dus eerst de lijst met huidige iptables-regels bekijken. Hiervoor wordt de vlag -L gebruikt:

sudo iptables -L
Chain INPUT (beleid ACCEPT)


doel prot opt ​​bronbestemming
Keten OUTPUT (beleid ACCEPT)
doel prot opt ​​bronbestemming

Zoals u kunt zien, bevat de lijst drie standaardketens (INPUT, OUTPUT en FORWARD), die elk een standaardbeleid hebben (momenteel ACCEPT). U kunt ook de kolomnamen zien. Maar deze lijst bevat niet de regels zelf, omdat Ubuntu geen standaard set regels heeft.

Met behulp van de vlag -S kan deze lijst worden bekeken in een andere indeling die de opdrachten weerspiegelt die nodig zijn om regels en beleid te activeren:

sudo iptables -S
-P INGANG ACCEPTEREN
-P VOORUIT ACCEPTEREN
-P UITGANG ACCEPTEREN

Om configuraties te repliceren, hoeft u alleen maar sudo iptables in te voeren aan het begin van elke resultaatregel. (Afhankelijk van uw configuraties kan deze procedure iets gecompliceerder zijn wanneer u op afstand verbinding maakt; als de regels om de huidige verbinding toe te staan ​​nog niet zijn ingesteld, moet u het DROP-beleid niet instellen.)

Om de huidige regels (indien aanwezig) opnieuw in te stellen, typt u:

sudo iptables -F

Nogmaals, het standaardbeleid is op dit punt erg belangrijk, omdat het niet zal worden gewijzigd met het vorige commando, ook al worden alle regels uit de ketens verwijderd.

Voordat u de regels voor een externe verbinding opnieuw instelt, moet u ervoor zorgen dat het ACCEPT-beleid is ingesteld in de INPUT- en OUTPUT-ketens. Dit wordt als volgt gedaan:

sudo iptables -P INPUT ACCEPTEREN
sudo iptables -P UITVOER ACCEPTEREN
sudo iptables -F

Nadat u de regels hebt gemaakt om externe verbindingen toe te staan, kunt u het DROP-beleid instellen. Laten we dus direct verder gaan met het maken van regels.

Iptables-regels maken

Zoals hierboven vermeld, richt deze tutorial zich op het werken met de INPUT-keten, omdat deze verantwoordelijk is voor inkomend verkeer. Eerst moet u rekening houden met de reeds genoemde regel - de regel die de huidige SSH-verbinding toestaat.

Het ziet er zo uit:

sudo iptables -A INPUT -m conntrack --ctstate GEVESTIGD, GERELATEERD -j ACCEPTEREN

Natuurlijk kan het in het begin ongelooflijk moeilijk lijken; om deze regel te begrijpen, bekijk de componenten ervan:

• -EEN INGANG: de -A vlag voegt ( toevoegen) regel aan het einde van de keten. Dit deel van de opdracht vertelt iptables om de regel toe te voegen aan het einde van de INPUT-keten.
• -m verbinding: naast een set basisfuncties heeft iptables ook een set extensies, of modules, die verantwoordelijk zijn voor extra functies van de firewall. Dit deel van de opdracht zegt dat de gebruiker toegang moet hebben tot de functies van de conntrack-module. Met deze module kunt u opdrachten gebruiken om te beslissen wat u met een pakket moet doen op basis van de relatie met eerdere verbindingen.
• —Ctstate: een van de beschikbare commando's bij het aanroepen van de conntrack-module. Met deze opdracht kunt u de relatie van pakketten tot andere eerder bekeken pakketten volgen. Het is ingesteld op ESTABLISHED (waarmee u pakketten kunt ontvangen die deel uitmaken van een bestaande verbinding) en RELATED (accepteert pakketten die zijn gekoppeld aan een reeds tot stand gebrachte verbinding). Dit deel van de regel is verantwoordelijk voor de huidige SSH-sessie.
• — JAANVAARDEN: geeft de actie (doel) aan die moet worden uitgevoerd op het pakket dat overeenkomt met de regel. In dit geval accepteert iptables pakketten die aan de vorige criteria voldoen.

Deze regel moet aan het begin worden geplaatst om ervoor te zorgen dat bestaande verbindingen overeenkomen met de regels, worden geaccepteerd en de keten verlaten zonder de DROP-regels te bereiken.

Door de lijst met regels op te vragen, ziet u de wijzigingen:

sudo iptables -L
Chain INPUT (beleid ACCEPT)
doel prot opt ​​bronbestemming
ACCEPTEER alles - overal en overal ctstate GERELATEERD, GEVESTIGD
Keten VOORUIT (beleid ACCEPTEREN)
doel prot opt ​​bronbestemming
Keten OUTPUT (beleid ACCEPT)
doel prot opt ​​bronbestemming

Nu u bekend bent met de basissyntaxis, kunt u nog een paar regels maken die een join accepteren.

Andere belangrijke connecties accepteren

Voorheen ontving iptables de opdracht om niet alle huidige verbindingen te verbreken, en ook om alle verbindingen die ermee verband houden te accepteren. Nu moet u regels maken die verbindingen accepteren die niet aan de bovenstaande criteria voldoen.

Laat twee poorten open: de SSH-poort (deze tutorial gebruikt de standaardpoort 22; als deze waarde is gewijzigd, vergeet dan niet de nieuwe waarde in te voeren); ga er daarnaast van uit dat deze computer standaard een webserver op poort 80 draait (voeg deze regel niet toe als dit niet het geval is).

De regels die moeten worden gebruikt om dergelijke regels te maken, zien er dus als volgt uit:

sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPTEREN

Zoals je kunt zien, lijken ze erg op de eerste regel; misschien hebben ze een nog eenvoudiger structuur. Nieuwe opties:

• — Ptcp: Deze optie staat pakketten toe die gebruikmaken van TCP (een stream-georiënteerd protocol dat door de meeste toepassingen wordt gebruikt omdat het betrouwbare communicatie mogelijk maakt).
• — dpoort: Deze optie is beschikbaar bij gebruik van de vlag -p tcp. Het specificeert de inkomende poort die moet overeenkomen met de pakketpoort. De eerste regel staat TCP-pakketten toe die naar poort 22 worden geleid, en de tweede regel accepteert TCP-verkeer dat naar poort 80 wordt geleid.

Nu moeten we nog een ACCEPT-regel maken om ervoor te zorgen dat de server werkt zoals verwacht. Meestal werken services samen door pakketten uit te wisselen; om dit te doen, gebruiken ze een pseudo-ring-netwerkinterface, een loopback-apparaat genaamd, dat verkeer terugleidt naar de bron en niet naar andere computers.

Dat wil zeggen, als service 1 een verbinding tot stand moet brengen met service 2 die luistert naar verbindingen op poort 4555, verzendt service 1 een pakket naar poort 4555 met behulp van een loopback-apparaat. Dit gedrag moet worden toegestaan ​​omdat het essentieel is voor veel programma's om goed te functioneren.

Voeg hiervoor de volgende regel toe:

sudo iptables -I INPUT 1 -i lo -j ACCEPTEREN

Het wijkt iets af van de vorige regels; beschouw het in meer detail:

• — lINGANG 1: De vlag -I vertelt iptables om de regel in te voegen. Deze vlag verschilt van de vlag -A (die de regel alleen aan het einde van de keten toevoegt); het geeft de keten aan waarin de regel moet worden ingevoegd en de locatie van de regel erin. In dit geval moet de regel helemaal aan het begin van de INPUT-keten worden ingevoegd, waardoor alle regels één positie zullen opschuiven. Deze regel moet aan het begin van de keten worden geplaatst, omdat het een van de hoofdregels is en niet afhankelijk mag zijn van andere.
• — llo: Deze regelcomponent laat pakketten die de lo-interface gebruiken door ("lo" is een andere naam voor een loopback-apparaat). Dit betekent dat elk pakket dat deze interface gebruikt, moet worden geaccepteerd.

Gebruik de vlag -S om de huidige regels te bekijken, aangezien de vlag -L geen informatie weergeeft (bijvoorbeeld de interface waaraan de regel is gebonden, wat erg belangrijk is in het geval van de laatste regel):

sudo iptables -S
-P INGANG ACCEPTEREN
-P VOORUIT ACCEPTEREN
-P UITGANG ACCEPTEREN
-A INGANG -i lo -j ACCEPTEREN
-A INPUT -m conntrack --ctstate GERELATEERD, VASTGESTELD -j ACCEPT
-A INPUT -p tcp -m tcp --dport 22 -j ACCEPTEREN
-A INPUT -p tcp -m tcp --dport 80 -j ACCEPTEREN

DROP-regels maken

Op dit moment zijn er dus 4 regels gemaakt die pakketten accepteren op basis van bepaalde criteria. De server blokkeert momenteel echter geen andere pakketten.

Als een pakket de INPUT-keten doorloopt en niet aan een van de vier regels voldoet, wordt het standaardbeleid (ACCEPT) uitgevoerd, dat dit pakket op de een of andere manier zal accepteren. Nu moet het veranderd worden.

Dit kan op twee manieren, die aanzienlijke verschillen hebben.

De eerste manier is om de standaard INPUT-keten te bewerken; typ hiervoor:

sudo iptables -P INPUT DROP

Dit beleid controleert en verwijdert alle pakketten die niet overeenkomen met de regels in de INPUT-keten. Een van de gevolgen van dit type constructie is dat het pakketten laat vallen, zelfs nadat de regels zelf zijn gewist.

Dit verhoogt natuurlijk het beveiligingsniveau van de server; dit kan echter ernstige gevolgen hebben als de gebruiker geen andere manier heeft om verbinding te maken met de server. Vaker wel dan niet, bieden hostingproviders een webconsole om in geval van dergelijke problemen verbinding te maken met de server. Deze console werkt als een virtuele lokale verbinding, dus iptables zal er niet op reageren.

U kunt de server de verbinding automatisch laten verbreken als de regels worden verwijderd. Dit maakt de server veiliger en moeilijker toegankelijk. Het betekent ook dat u regels aan het einde van de keten kunt toevoegen en dat alle ongewenste pakketten worden verwijderd.

Een alternatieve benadering is om een ​​regel toe te voegen aan het einde van de keten om alle niet-overeenkomende pakketten te verwijderen met behoud van het ACCEPT-beleid.

Om het ACCEPT-beleid terug te sturen naar de INPUT-keten, typt u:

sudo iptables -P INPUT ACCEPTEREN

Nu kun je een regel toevoegen aan het einde van deze keten die alle niet-overeenkomende pakketten laat vallen:

sudo iptables -A INPUT -j DROP

Onder normale bedrijfsomstandigheden is het resultaat precies hetzelfde als bij het gebruik van het DROP-beleid. Deze regel verwijdert elk pakket dat het bereikt, waardoor wordt voorkomen dat pakketten die niet voldoen aan de opgegeven regels de server bereiken.

In principe wordt de tweede benadering gebruikt wanneer het nodig is om het ACCEPT-beleid te behouden dat verkeer accepteert. Dat wil zeggen, zelfs als alle regels zijn gewist, heeft de gebruiker nog steeds toegang tot de machine op het netwerk. Met deze aanpak kunnen standaardacties worden ondernomen zonder dat het beleid dat op de lege keten wordt toegepast, hoeft te worden gewijzigd.

Dit betekent natuurlijk ook dat elke regel die aan het einde van de keten moet worden ingevoegd, vóór de weggooiregel moet komen. Dit kan worden gedaan door de resetregel tijdelijk te verwijderen:

sudo iptables -D INPUT -j DROP
sudo iptables -A INPUT new_rule
sudo iptables -A INPUT -j DROP

of door een nieuwe regel in te voegen aan het einde van de sport (maar vóór de resetregel), met vermelding van het regelnummer. Om een ​​regel aan regel 4 toe te voegen, typt u:

sudo iptables -I INPUT 4 new_rule

Als er veel regels zijn, is het handmatig berekenen van het regelnummer nogal problematisch; in dit geval kan iptables de regels nummeren:

sudo iptables -L --regelnummers
Chain INPUT (beleid DROP)

1 ACCEPTEER alles - overal en overal
2 ACCEPTEER alles - overal en overal ctstate GERELATEERD, GEVESTIGD
3 ACCEPTEER tcp - overal en overal tcp dpt: ssh
4 ACCEPTEER tcp - overal en overal tcp dpt: http
Keten VOORUIT (beleid ACCEPTEREN)
num target prot bronbestemming
Keten OUTPUT (beleid ACCEPT)
num target prot bronbestemming

Dit zorgt ervoor dat de regel op de juiste regel is ingevoerd.

IPtables-instellingen opslaan

Standaard blijven alle niet-opgeslagen regels van kracht tot de volgende herstart van de server; niet-opgeslagen regels gaan onmiddellijk verloren bij het opnieuw opstarten.

Dit is in sommige gevallen handig omdat het gebruikers die zichzelf per ongeluk hebben buitengesloten, toegang geeft tot de server. In de meeste gevallen is het echter handiger om de regels op te slaan en te laden wanneer de server start.

Dit kan op verschillende manieren; de eenvoudigste is om het iptables-persistent pakket te gebruiken, dat kan worden gedownload van de standaard Ubuntu-repository:

sudo apt-get update
sudo apt-get install iptables-persistent

Tijdens de installatie geeft het pakket aan of u de huidige regels wilt opslaan voor verder automatisch laden; als de huidige regels zijn getest (u kunt SSH-verbindingen maken) en aan alle vereisten voldoen, kunt u ze opslaan.

Wanneer de installatie is voltooid, verschijnt een nieuwe service genaamd iptables-persistent die wordt gestart wanneer de server opnieuw wordt opgestart en de ingestelde regels hervat.

resultaten

Deze handleiding helpt u bij het configureren van de firewall volgens de vereisten van de gebruiker. Natuurlijk zijn er nog veel meer van dergelijke hulpprogramma's, en sommige zijn misschien gemakkelijker te gebruiken; iptables is echter een van de beste tools die er zijn, al was het maar omdat het enkele van de basisstructuren van netfilter demonstreert en in veel systemen is opgenomen.

Linux heeft een ingebouwde firewall genaamd Netfilter. Volgens de officiële website van het project:

netfilter is een verzameling systeemberichten binnen de Linux-kernel waarmee kernelmodules callback-functies van de netwerkstack kunnen registreren. De geregistreerde callback-functie verwerkt elk pakket dat door de netwerkstack gaat.

De firewall in Linux wordt bestuurd door iptables die IPv4-filterfuncties heeft, ip6tables filtert IPv6. Deze tutorial legt uit hoe je Netfilter (iptables) kunt gebruiken op CentOS / RHEL / Fedora / Redhat Enterprise Linux. Dit artikel bevat basisvoorbeelden van het configureren van iptables in Linux voor inbraakbeveiliging.

Voorbeelden van het gebruik van iptables

• De meeste acties die in dit artikel worden vermeld, zijn geschreven met de veronderstelling dat ze worden uitgevoerd als root vanuit bash of een andere moderne shell. Voer geen opdrachten in op het externe systeem, omdat u de toegang voor uzelf kunt uitschakelen.
• Voor demo-doeleinden heb ik ubuntu 10.04 gebruikt, maar de opdrachten zouden met elke moderne distributie moeten werken.

De status van uw firewall weergeven

Chain INPUT (beleid ACCEPT 1810K pakketten, 126M bytes) pkts bytes doel prot opt-in uit bronbestemming 7418K 1070M ACCEPTEREN udp - * * 0.0.0.0/0 0.0.0.0/0 udp dpt: 1194 881 52520 ACCEPTEREN tcp - eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpt: 2222 vlaggen: 0x17 / 0x02 status NIEUW Chain FORWARD (beleid ACCEPT 5628K packets, 482M bytes) pkts bytes target prot opt-in out source bestemming 0 0 ACCEPT tcp - eth0 tun0 0.0 .0.0 / 0 0.0.0.0/0 tcp dpt: 1111 staat NIEUW, GERELATEERD, GEVESTIGD 599K 539M ACCEPT udp - eth0 * 0.0.0.0/0 10.1.1.6 udp dpt: 1112 staat NIEUW, GERELATEERD, GEVESTIGD KetenUITVOER (beleid ACCEPTEREN 4959K pakketten, 880M bytes) pkts bytes target prot opt ​​​​in out source bestemming
De toetsen in het voorbeeld betekenen:

• L: Maak een lijst van de regels.
• v: Geeft gedetailleerde informatie weer. Deze toets geeft de interfacenaam, regelparameters en TOS-maskers weer. Packet- en bytetellers worden ook in de lijst weergegeven, met een "K"-achtervoegsel, "M" of "G", afhankelijk van de vereiste vermenigvuldiger.
• N: IP-adressen niet oplossen, digitaal weergeven. Versnelt terugtrekking.

Stop, herstart, start firewall

• F: Wist alle regels (flushing).
• x: een keten verwijderen
• t <таблица>: Tabel selecteren en regels verwijderen.
• P: het standaardbeleid instellen (zoals DROP, REJECT of ACCEPT).

Firewallregels verwijderen

• NS: verwijder een of meer regels uit de opgegeven keten

Firewallregels toevoegen

Firewallregels opslaan

Firewallregels herstellen

Standaard firewallbeleid instellen

De netwerkadressen van het lokale netwerk op de externe interface blokkeren

• 10.0.0.0/8 -j (A)
• 172.16.0.0/12 (B)
• 192.168.0.0/16 ©
• 224.0.0.0/4 (MULTICAST D)
• 240.0.0.0/5 (E)
• 127.0.0.0/8 (LOOPBACK)

IP-blokkering

Inkomende poortverzoeken blokkeren

Uitgaande IP-blokkering

Pakketten loggen en blokkeren

Commentaar van:

Vooral bij duidelijk linkshandig verkeer kunt u dit beter niet doen. LOG kan alleen strikt worden ingevoegd met de limiet -m, anders zal elke DoS-aanval vele malen effectiever zijn: in feite krijgt de aanvaller indirect een direct pad met intense impact, rechtstreeks op het bestandssysteem van de server.

Loggen en blokkeren van pakketten met een beperkt aantal logboekvermeldingen

Verkeer van een Mac-adres blokkeren of toestaan

ICMP-pingverzoeken weigeren of toestaan

Een reeks IP-adressen openen

Openbare poorten sluiten of openen

Beperk het aantal gelijktijdige verbindingen met de server voor elke client op IP

• --connlimit-above 3: Of het aantal bestaande verbindingen hoger is dan 3.
• --connlimit-mask 24: Hosts groeperen door