NetFilter Masquerading firewall (iptables)
v1.2.4 - 27 juni 2004
(C) Bart Geverts <web(at)sys1(dot)ath(dot)cx>, 2003
Licentie: GFDL 1.2
Inhoud
Inleiding
Netwerk theorie
Firewall theorie
NetFilter theorie
Masquerading
NetFilter installatie
Modules
Voorbeeld rules
Weergave van standaard instelling
Alle rules tonen
Alle rules verwijderen en terugkeren naar de standaard instelling
Eenvoudige 'RETURN' rule
Default policy opgeven
Verkeer op localhost toestaan
Uitgaande TCP connectie toestaan
Uitgaande UDP connectie toestaan
Uitgaande ping toestaan
Inkomende ping toestaan
Uitgaande traceroute toestaan
Inkomende traceroute toestaan
Masquerading
Gnomemeeting
TCP server openstellen
UDP server openstellen
Gereserverde netwerken uitsluiten
Onmogelijke combinaties van TCP-flags blokkeren
Redirecting
Forwarding
Loggen
Nieuwe chains toevoegen
iptables-save en iptables-restore
Kant-en-klare NetFilter scripts
FAQ
Inleiding
Dit verhaal heb ik geschreven omdat er weinig nederlandstalige documentatie over dit onderwerp is te vinden en de documentatie die er is, is erg ontoegankelijk. Ik heb geprobeerd een toegankelijk nederlandstalig verhaal over firewalls te maken. Of ik daarin ben geslaagd is aan de lezer :). Dit verhaal is geplaatst onder de GNU Free Document License versie 1.1 of later. De GFDL is te lezen op http://www.gnu.org/copyleft/fdl.html.
Het firewall subsysteem van de Linux 2.4/2.6 kernel heet NetFilter. Hiermee kunnen netwerk pakketjes worden gefilterd (firewall), allerlei NAT (Network Address Translation) acties worden uitgevoerd en pakketjes op andere manieren worden "gemangled". Het belangrijkste deel van NetFilter is aanwezig in kernelspace, alleen om NetFilter te bewerken is een apart userspace programma nodig. Dit programma heet "iptables" en wordt met vrijwel elke distributie meegeleverd. NetFilter is een behoorlijk complex systeem. Om een goede firewall op te zetten is dus ook de nodige kennis nodig. Allereerst dient de kernel geschikt te zijn (gemaakt) voor NetFilter. Dit wordt beschreven in NetFilter installatie. Daarnaast is enige theorie van netwerken in het algemeen en firewalls in het bijzonder nodig. Als die ontbreekt is Firewall theorie een goed beginpunt. Na een geslaagde installatie en kennis van de nodige theorie kan iedereen aan de slag met firewalls en alle andere mogelijkheden van NetFilter. In Voorbeeld rules is een groot aantal praktijkvoorbeelden van NetFilter te vinden. Tenslotte is er een FAQ waarin een aantal vragen worden beantwoord.
Ik stel mij als schrijver van dit verhaal niet aansprakelijk voor wat voor gevolgen dan ook die hier uit voortvloeien. Als gegevens verloren gaan, hardware defect raakt, je huis afbrandt of andere gevolgen; ik stel me daar niet aansprakenlijk voor.
Netwerk theorie
Netwerkverkeer bestaat uit pakketjes. Elk pakketje bestaat uit een header en een body. In de body staat de data die verstuurd wordt, in de header staat de informatie die voor het versturen nodig is, zoals bijvoorbeeld:
- soort pakket (icmp, tcp of udp)
- source address (ipadres waar pakket vandaan komt)
- destination address (ipadres waar pakket naartoe gaat)
- source port (portnummer waar pakket vandaan komt)
- destination port (portnummer waar pakket naartoe gaat)
- tcp-flags
Er staat nog meer in, maar dat is voorlopig niet belangrijk. Een port kan je zien als een in- of uitgang met een nummer. Normaal gesproken heb je 65535 poorten. De eerste 1024 (0 tot en met 1023) heten geprivileerd, de rest (1024 tot en met 65535) heet ongeprivileerd. De meeste servers (bv http) luisteren op een geprivileerde port (http op 80). Een client connect meestal vanaf een ongeprivileerde poort.
Als je bijvoorbeeld met je browser een website bezoekt worden er twee tcp connecties opgezet. Eentje van jouw computer naar de webserver en eentje terug. De eerste connectie (de uitgaande) loopt van een ongeprivileerde poort op jouw computer naar poort 80 van de webserver. De andere connectie (de ingaande) loopt van poort 80 op de webserver naar de ongeprivileerde poort op jouw computer. Welke ongeprivileerde poort dat precies is kan vooraf niet gezegd worden. Soms wordt daarvoor de eerst voorkomende vrije poort genomen, maar het is ook mogelijk dat die poort volledig willekeurig wordt gekozen.
TCP/IP is een set van protocollen welke zijn ontwikkeld om verschillende computers met elkaar te kunnen laten communiceren. IP staat voor Internet Protocol en TCP is het meeste bekende protocol uit de TCP/IP set. TCP staat voor Transmission Control Protocol, wat inhoudt dat de elk verstuurd pakketje wordt gecontroleerd en als er iets niet klopt, wordt het pakketje opnieuw verstuurd. De data komt dus altijd exact over zoals het bedoelt was. Maar TCP is niet het enige protocol. Een ander bekend protocol is UDP; User Datagram Protocol. Hierbij worden verstuurde pakketjes niet gecontroleerd. Het is dus mogelijk dat zo nu en dan een pakketje niet of misvormt bij de ontvanger aankomt, maar het is sneller dan TCP. UDP wordt vooral gebruikt voor het versturen van videostreams en voor spelletjes over internet (bv Quake). Het derde belangrijke protocol is ICMP, dat staat voor Internet Control Message Protocol. ICMP wordt gebruikt voor het versturen van berichten op laag niveau. Het 'ping' commando maakt bijvoobeeld gebruik van ICMP, maar ook verschillende foutmeldingen worden langs dit protocol verstuurd.
Netwerkkaarten, PPP-adapters enz worden interfaces genoemd. De eerste ethernetadapter in een computer wordt bij Linux meestal "eth0" genoemd, de tweede "eth1", enz. PPP-adapters heten "ppp0", "ppp1", enz. Om in een keer alle interfaces van een bepaald type (bv alle eth interfaces) aan te duiden, kan het nummer worden vervangen door een '+'. Als in een machine een eth0 en een eth1 zitten, kan gebruik worden gemaakt van 'eth+'.
Op de website van Warriors of the Net is een MPEG film van ruim 12 minuten te downloaden waarin het principe van de netwerkpakketjes op een leuke manier wordt gevisualiseerd. URL: http://ftp.sunet.se/pub/tv+movies/warriors/warriors-700-nl-VBR.mpg
Firewall theorie
Een firewall kan je zien als een grote zeef. De zeef bestaat uit een aantal regels die bepaalde pakketten beschrijven. Als een pakket aan de beschrijving voldoet wordt het pakket geaccepteerd (of geweigerd, afhankelijk van wat er in de regel gezegd wordt) en kan de firewall het volgende pakket afwerken. Als een pakket door geen enkele regel wordt beschreven en dus uiteindelijk onderaan de firewall belandt, wordt gekeken naar het standaard regime. Dat standaard regime kan zijn: 'weiger alles' of 'accepteer alles'. In dit verhaal wordt het 'Weiger alles' regime gebruikt.
Dit principe blijkt in de praktijk vaak onduidelijk, dus een simpel voorbeeldje is op z'n plaats. Het lijkt debiel, maar als je dit snapt, snap je ook het firewall principe. We hebben een aantal houten blokjes, verschillende kleuren en vormen :o)
- blauw en rond
- blauw en vierkant
- rood en rond
- rood en vierkant
- groen en rond
- groen en vierkant
Ons standaard regime (default policy) is 'weiger alles':
iptables -P DROP
Alle blokjes die rond zijn willen we doorlaten, behalve als ze groen zijn. Verder willen we alle blauwe blokjes doorlaten, zowel rond als vierkant:
iptables --kleur groen -j DROP (regel 1) iptables --vorm rond -j ACCEPT (regel 2) iptables --kleur blauw -j ACCEPT (regel 3)
Nu gaan we stuk voor stuk alle blokjes door de firewall heenhalen:
blauw en rond regel 1: de kleur is niet groen, dus het blokje voldoet niet aan de regel. Dan komen we bij de volgende regel. regel 2: de vorm is rond, en dus voldoet het blokje aan de regel. De regel zegt dat we die blokjes moeten ACCEPTeren. Dus we accepteren het blokje en we kunnen aan het volgende blokje beginnen.
blauw en vierkant regel 1: de kleur is niet groen, dus het blokje voldoet niet aan de regel. Dan komen we bij de volgende regel. regel 2: de vorm is niet rond, dus het blokje voldoet niet aan de regel. Dan komen we bij de volgende regel. regel 3: de kleur is blauw, dus: accepteren.
rood en rond regel 1 voldoet niet, regel 2 voldoet wel, dus: accepteren.
rood en vierkant regel 1 voldoet niet, regel 2 voldoet niet en regel 3 voldoet niet. nu kijken we naar het standaard regime (DROP), dus weigeren we het blokje.
groen en rond regel 1 voldoet, want de kleur is groen, dus: weigeren.
groen en vierkant regel 1 voldoet, want de kleur is groen, dus: weigeren.
Een firewall hoeft uiteraard geen houten blokjes tegen te houden, maar pakketjes en pakketjes hebben geen kleur en vorm, maar een sourceport en destination address. In de praktijk maakt dat eigelijk niks uit.
NetFilter theorie
Hoewel het blokjesverhaal een hoop duidelijk maakt, zitten NetFilter firewalls toch iets gecompliceerder in elkaar. Zo kent NetFilter een aantal principes:
- tables
- chains
- policies
- rules
- targets
- states
Standaard beschikt NetFilter over een drietal 'tables':
- filter
- nat
- mangle
De 'filter' table is de belangrijkste (en default) table. Deze table beschikt over de INPUT, FORWARD en OUTPUT chain. De 'nat' table wordt gebruikt wanneer een pakket een nieuwe connectie start en beschikt over de PREROUTING, OUTPUT en POSTROUTING chain. De laatste table, mangle, beschikte tot en met de 2.4.17 kernel over twee chains: PREROUTING en OUTPUT. Sinds de 2.4.18 kernel zijn daar nog drie chains bijgekomen: INPUT, FORWARD en POSTROUTING. Het gebruik van de verschillende tables en chains wordt duidelijk gemaakt in de 'Voorbeeld rules'.
Elk van de drie bovengenoemde tables heeft een 'default policy'. Daarmee wordt aangegeven wat er moet gebeuren met pakketten die in een de betreffende table niet worden beschreven in een rule. De mogelijke default policies zijn:
- pakketten accepteren (ACCEPT)
- pakketten weigeren (RETURN, DROP)
Dat weigeren kan op verschillende manieren, nl:
- weigeren en de afzender vertellen dat je z'n pakket niet wil hebben (RETURN)
- weigeren en niks tegen de afzender zeggen (DROP)
Elke methode heeft z'n voor- en nadelen. Het is afhankelijk van de situatie wat je het beste kan doen.
In de 'rules' worden pakketten beschreven. Er zijn vele manieren waarop pakketten geselecteerd kunnen worden. Om maar wat te noemen: source, protocol, destination-port, tcp-vlaggen, enz. Op alle gegevens die in de header van netwerkpakketjes staan kunnen ze geselecteerd worden.
In elke rule moet een 'target' worden opgegeven; wat er met een pakketje moet gebeuren dat aan de rule voldoet. Hiervoor worden dezelfde doelen gebruikt als voor de policies: ACCEPT, RETURN en DROP (verderop in dit verhaal zal blijken dat er nog meer targets zijn).
Tenslotte zijn er nog de 'states', ofwel de staat waarin een connectie kan verkeren. Dit is één van de grootste vernieuwingen sinds ipchains. Nieuwe en bestaande connecties kunnen van elkaar worden onderscheiden.
Masquerading
Masquerading, of eigelijk IP masquerading, is een vorm van Network Address Translation (NAT) om meerdere computers die in een lokaal netwerk hangen, via een gateway met het internet te verbinden. Dit is ook wel bekend als 'internet delen'.
Want wat is het probleem? Als een computer die via een gateway het internet opgaat zal een pakket een source address hebben dat tot het lokale netwerk behoort. De computer aan de andere kant zal je dan nooit terug kunnen vinden. Dus we zullen het lokale ipadres moeten maskeren. Zeg maar: vervangen door het internet ipadres van de gateway en op de gateway moeten we onthouden wat we gedaan hebben totdat we antwoord krijgen.
De regels die nodig zijn voor het delen van een internetverbinding zijn te vinden in de masquerading voorbeeld rules.
NetFilter installatie
Om met NetFilter aan de gang te kunnen gaan moet aan twee voorwaarden worden voldaan:
- iptables moet geinstalleerd zijn
- kernel moet geschikt zijn voor NetFilter
Bij de meeste distributies wordt iptables standaard al geinstalleerd. Als dat niet het geval is kan iptables op de CD of op de website van de distributie worden gevonden.
Ook zijn de meeste standaard kernels al geschikt voor NetFilter. Mocht dat niet het geval zijn, dan zal er een nieuwe kernel gecompileerd moeten worden. Een algemene beschijving hiervoor is te vinden in de NedDocWiki. Voor NetFilter zijn de volgende opties van belang:
NetWorking options --->
[*] Network packet filtering
IP: NetFilter Configuration --->
alle opties, behalve de laatste twee ("ipchains support" en "ipfwadm support")
De opties kunnen als KernelModule [M] gecompileerd worden of direct in de kernel gelinkt [*].
Modules
Wanneer er gebruik wordt gemaakt van kernel modules zijn de volgende modules altijd nodig:
- ip_tables
- iptables_filter
Een groot verschil tussen iptables en de voorganger ipchains is het verschijnsel 'connection tracking'. Hiermee kan iptables bestaande connecties onderscheiden van nieuwe connecties. Om hiervan gebruik te kunnen maken zijn de volgende modules vereist:
- ip_conntrack
- ip_state
Als er gebruik wordt gemaakt van masquerading is de module 'ipt_MASQUERADE' nodig. Voor het masqueraden van FTP connecties zijn de modules 'ipt_conntrack_ftp' en 'ipt_nat_ftp'. Tenslotte is 'ipt_LOG' nodig om meldingen te loggen.
Hiermee zijn de belangrijkste modules genoemd, maar voor speciale toepassingen is er nog een groot aantal andere modules beschikbaar. Een volledige lijst van alle modules is te vinden in '/lib/modules/<kernelversie>/kernel/net/ipv4/netfilter'. In de kernel en iptables documentatie is hierover meer informatie te vinden.
Voorbeeld rules
Op deze pagina zullen aan de hand van praktijk voorbeelden enkele toepassingen van NetFilter worden gedemonstreerd. Er worden regelmatig voorbeeldjes gegeven waarbij netwerk interfaces worden gebruikt. Overal is 'ppp0' de externe interface (naar het internet, "untrusted") en 'eth0' de interface waar het lokale ("trusted") netwerk aanhangt. Tenzij anders vermeldt, wordt er van uitgegaan dat er geen rules aanwezig zijn en de defaultpolicies op ACCEPT staan. Hoe dit is te controleren staat in 'Alle rules tonen'. De weergave zou er als volgt uit moeten zien:
Weergave van een standaard instelling
# iptables -L -n Chain INPUT (policy ACCEPT) target prot opt source destination Chain FORWARD (policy ACCEPT) target prot opt source destination Chain OUTPUT (policy ACCEPT) target prot opt source destination # iptables -L -n -t nat Chain PREROUTING (policy ACCEPT) target prot opt source destination Chain POSTROUTING (policy ACCEPT) target prot opt source destination Chain OUTPUT (policy ACCEPT) target prot opt source destination # iptables -L -n -t mangle Chain PREROUTING (policy ACCEPT) target prot opt source destination Chain INPUT (policy ACCEPT) target prot opt source destination Chain FORWARD (policy ACCEPT) target prot opt source destination Chain OUTPUT (policy ACCEPT) target prot opt source destination Chain POSTROUTING (policy ACCEPT) target prot opt source destination
Alle rules tonen
Een overzicht van alle rules in een bepaalde table is op te vragen met
# iptables -L -n [-t <table>]
Als de -t optie wordt weggelaten wordt de 'filter' table weergegeven.
Alle rules verwijderen en terugkeren naar de standaard instelling
Als je zelf een firewall gaat onwikkelen is het handig om een 'clean-up' scriptje bij de hand te hebben. Dit is een script dat ten eerste alle chains leegmaakt en ten tweede alle default policies op 'ACCEPT' zet.
Zo'n script zou er als volgt uit kunnen zien:
iptables --table filter --flush iptables --table filter --delete-chain iptables --table filter --zero iptables --table nat --flush iptables --table nat --delete-chain iptables --table nat --zero iptables --table mangle --flush iptables --table mangle --delete-chain iptables --table mangle --zero iptables --table filter --policy INPUT ACCEPT iptables --table filter --policy OUTPUT ACCEPT iptables --table filter --policy FORWARD ACCEPT iptables --table nat --policy PREROUTING ACCEPT iptables --table nat --policy POSTROUTING ACCEPT iptables --table nat --policy OUTPUT ACCEPT iptables --table mangle --policy PREROUTING ACCEPT iptables --table mangle --policy INPUT ACCEPT iptables --table mangle --policy FORWARD ACCEPT iptables --table mangle --policy OUTPUT ACCEPT iptables --table mangle --policy POSTROUTING ACCEPT
Een eenvoudige 'RETURN' rule
Dit is een eenvoudig voorbeeldje waarin een eventuele telnetserver van de buitenwereld wordt afgesloten.
# iptables -A INPUT -p tcp --destination-port 23 -i ppp0 -j RETURN
Allereerst valt op dat er geen table wordt aangegeven. In dat geval wordt de standaard table 'filter' bedoeld. Met de '-A INPUT' wordt de INPUT chain aangegeven. Binnenkomende pakketten dus. Met '-p tcp' en '--destination-port 23' wordt aangegeven dat het gaat om poort tcp/23, ofwel telnet. Welke netwerk interface gecontroleerd moet worden wordt aangegeven met de '-i' optie. In dit geval dus 'ppp0'. Tenslotte wordt met '-j RETURN' aangegeven dat we de afzender op de hoogte willen stellen van de weigering.
Een default policy opgeven
Het is niet handig om de default policies op 'ACCEPT' te laten staan en vervolgens alle ongewenste connecties onmogelijk te maken. Een veel betere manier is om standaard alle connecties te weigeren en alleen toe te staan wat nodig is. Daar mee wordt voorkomen dat er ongewenste connecties over het hoofd worden gezien. Stel dat bijvoorbeeld een Apache webserver wordt gegrepen door de 'Slapper' worm. Als de default policy 'DROP' is en er geen uitgaande connecties op poort 2000/udp mogelijk zijn, zal deze worm weinig schade kunnen aanrichten. Als de default policies 'ACCEPT' zouden zijn en alleen een paar (bij de beheerder bekende) riskante poorten zijn afgesloten, kan de worm vrolijk z'n gang gaan. Voor de filter table kunnen de default policies als volgt op 'DROP' worden ingesteld:
iptables --table filter --policy INPUT DROP iptables --table filter --policy OUTPUT DROP iptables --table filter --policy FORWARD DROP
Uiteraard is dit ook voor de overige tables en chains in te stellen. De firewall laat nu dus helemaal niets meer door. Om bepaalde gewenste connecties mogelijk te maken moeten dus rules worden opgesteld.
TIP: Als je niet fysiek achter de firewall machine zit en de default policies allemaal op 'DROP' zet, is de PC daarna absoluut onbereikbaar! Let hierbij dus goed op wat je doet.
Verkeer op localhost toestaan
Om correct te kunnen functioneren moet alle verkeer op localhost mogelijk zijn. Met een defaultpolicy waarbij alles geDROPt wordt is dat niet het geval. Dan moet expliciet worden aangegeven dat dat toegestaan is:
iptables --table filter -A INPUT --source 127.0.0.1 -i lo -j ACCEPT iptables --table filter -A OUTPUT --destination 127.0.0.1 -o lo -j ACCEPT
Een uitgaande TCP connectie toestaan
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. Zonder rules is er dus geen verkeer mogelijk. Om een uitgaande TCP connectie mogelijk te maken (bv met een browser een website bezoeken), is het belangrijk om te snappen wat de tcp-vlaggen inhouden.
Voor het opbouwen van een TCP connectie moet naar de tcp-flags worden gekeken. De TCP-header bevat zes velden die wel of niet geset kunnen zijn:
- URG: Deze vlag staat voor "urgent pointer" en wordt geset als de ontvangende host de data met voorrang moet verwerken.
- ACK: De "acknowledge" vlag wordt geset als het pakket geldig is en de onvangende host de data kan vertrouwen.
- PSH: Als de "push" vlag is geset moet het pakket direct worden doorgestuurd naar de applicatie die de moet ontvangen. Normaal wordt de data eerst in een buffer opgeslagen. Deze flag wordt vaak gebruikt voor remote-shell doeleinden, waardoor een ingetoetste letter vrijwel direct op het scherm zichtbaar wordt.
- RST: Deze "reset" flag wordt geset als de ontvangende host de connectie moet herstellen; wat nodig is als er problemen zijn opgetreden.
- SYN: De "synchronize" flag, wordt naar de ontvanger gestuurd als deze pakketten moet synchroniseren. Dit is nodig als de bronhost nieuwe data wil versturen.
- FIN: Met de "finish" flag geeft de bronhost aan dat de verzending klaar is. Nadat ook de doelhost een pakket terugstuurt met een gesette "fin" flag wordt de verbinding verbroken.
Voordat er daadwerkelijk data verstuurd kan worden over een TCP connectie, moeten de client en de server een zogenaamde 'handshake' uitvoeren. Als eerste zal de client een 'SYN' naar de server sturen. Als de server in staat is om de client te bedienen zal hij antwoorden met een 'SYN,ACK'. Nadat de client tenslotte een 'ACK' naar de server heeft gestuurd, is de TCP connectie opgebouwd en kan er data worden verstuurd. Schematisch ziet deze handshake er als volgt uit:
------ SYN ----> (1)
CLIENT <--- SYN,ACK --- SERVER (2)
------ ACK ----> (3)
Voor het opgeven van de tcp-vlaggen wordt de optie '--tcp-flags' gebruikt. Deze optie kent twee parameters welke worden gescheiden door een spatie. De eerste parameter geeft aan welke vlag(gen) er gecontroleerd moeten worden en de tweede parameter geeft aan welke vlaggen geset moeten zijn. Als er meerdere vlaggen tegelijk worden opgegeven dienen deze te worden gescheiden met een komma. Dit principe wordt in de volgende voorbeeldjes duidelijk gemaakt:
Controleer de status van de 'ACK' flag en de 'SYN' flag. De 'SYN' flag moet geset zijn en de 'ACK' flag moet niet geset zijn:
--tcp-flags SYN,ACK SYN
Controleer de status van de 'ACK' flag en de 'SYN' flag. De 'SYN' flag moet niet geset zijn en de 'ACK' flag moet wel geset zijn:
--tcp-flags SYN,ACK ACK
Om in één keer alle vlagen te noemen kan gebruik worden gemaakt van 'ALL' en om geen enkele vlag aan te geven bestaat 'NONE'. Controleer de status van de alle flags. De 'SYN' flag en de 'ACK' flag moeten beide geset zijn. De overige vlaggen moeten niet geset zijn:
--tcp-flags ALL SYN,ACK
De rules om uitgaande TCP connecties mogelijk zouden er dus als volgt uit kunnen zien:
iptables --table filter -A OUTPUT -o ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN SYN -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN SYN,ACK -j ACCEPT
iptables --table filter -A OUTPUT -o ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN ACK -j ACCEPT
Het leuke van NetFilter is dat het mogelijk is om te letten op de staat waarin de verbinding verkeert. De mogelijke 'states' zijn: NEW, ESTABLISHED, RELATED en INVALID. Pakketten die behoren tot connecties die nog niet eerder zijn gezien vallen onder 'NEW'. 'ESTABLISHED' geeft aan dat er al eerder pakketten van dat type zijn langsgekomen. Met 'RELATED' wordt gedoeld op pakketten die op enige manier zijn gerelateerd aan een bepaalde bekende connectie; bv ftp-data als er ftp-controle pakketten zijn langsgeweest. Pakketten die gerelateerd zijn aan onbekende connecties zijn 'INVALID'.
Met behulp van de 'state' is het mogelijk om de bovenstaande regels nog wat te verfijnen:
iptables --table filter -A OUTPUT -o ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN SYN -m state --state NEW -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN SYN,ACK \
-m state --state ESTABLISHED,RELATED -j ACCEPT
iptables --table filter -A OUTPUT -o ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN ACK -m state \
--state ESTABLISHED,RELATED -j ACCEPT
De TCP connectie kan nu opgebouwd worden, maar om ook data transport mogelijk te maken moeten inkomende gerelateerde pakketten met alleen de 'ACK' flag geset zijn en dat geldt ook voor de uitgaande gerelateerde pakketten. Dat wordt mogelijk gemaakt met de volgende regels:
iptables --table filter -A INPUT -i ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN ACK \
-m state --state ESTABLISHED,RELATED -j ACCEPT
iptables --table filter -A OUTPUT -o ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN ACK \
-m state --state ESTABLISHED,RELATED -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN ACK \
-m state --state ESTABLISHED,RELATED -j ACCEPT
Na het versturen van alle data moet het ook mogelijk zijn om een TCP connectie te verbreken door middel van de 'FIN' vlag. Dat gebeurd op de volgende manier:
iptables --table filter -A INPUT -i ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN ACK,FIN \
-m state --state ESTABLISHED,RELATED -j ACCEPT
iptables --table filter -A OUTPUT -o ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN ACK,FIN \
-m state --state ESTABLISHED,RELATED -j ACCEPT
Tenslotte moet in geval van problemen de connectie hersteld kunnen worden. Daartoe moet de 'RST' flag gebruikt in zowel de input als de output:
iptables --table filter -A INPUT -i ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN RST \
-m state --state ESTABLISHED,RELATED -j ACCEPT
iptables --table filter -A OUTPUT -o ppp0 -p tcp \
--tcp-flags SYN,ACK,RST,FIN RST \
-m state --state ESTABLISHED,RELATED -j ACCEPT
Met deze regels kunnen uitgaande TCP connecties worden opgezet, er data over worden verstuurt, worden afgesloten en worden herstelt. Voor het onderhouden van een ssh connectie met een externe host of het bezoeken van een website op een externe webserver is dit voldoende.
Een uitgaande UDP connectie toestaan
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. UDP zit eenvoudiger in elkaar dan TCP en beschikt niet over vlaggen. Daarom dient voor elke toepassing een apart stel regels te worden opgesteld.
De meest voorkomende UDP connectie wordt opgezet bij het resolven van een IPAdres of een Hostname. Hierbij vind er datatransport plaats over poort 53. Dat is mogelijk te maken met de volgende twee regels:
iptables --table filter -A OUTPUT -o ppp0 -p udp \
--destination-port 53 -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p udp \
--source-port 53 -m state --state ESTABLISHED -j ACCEPT
In dit bovenstaande voorbeeld wordt ervan uit gegaan dat de default policy DROP is. Voor de output kan geen 'state' worden opgegeven omdat er geen onderscheid kan worden gemaakt tussen afzonderlijke sessies. Bij de eerste resolve sessie is de state 'NEW', maar bij de tweede en volgende binnen een bepaalde tijdsduur is dit 'ESTABLISHED' geworden.
Uitgaande ping toestaan
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. Voor een 'ping' wordt gebruik gemaakt van het ICMP protocol en bestaat uit twee delen: eerst wordt er een 'echo-request' verstuurd en vervolgens zal er een 'echo-reply' worden ontvangen.
iptables --table filter -A OUTPUT -o ppp0 -p icmp \
--icmp-type echo-request -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p icmp \
--icmp-type echo-reply -j ACCEPT
Inkomende ping toestaan
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. De regels voor de inkomende ping zijn precies het omgekeerde van de uitgaande ping. Om 'flooding' te voorkomen wordt het aantal inkomende pakketten gelimiteerd.
iptables --table filter -A INPUT -i ppp0 -p icmp \
--icmp-type echo-request -m limit \
--limit 5/minute --limit-burst 10 -j ACCEPT
iptables --table filter -A OUTPUT -o ppp0 -p icmp \
--icmp-type echo-reply -j ACCEPT
Uitgaande traceroute toestaan
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. Tijdens het uitvoeren van een 'traceroute' naar een externe host worden er zowel ICMP als UDP connecties opgezet.
iptables --table filter -A OUTPUT -o ppp0 -p udp \
--source-port 32769:65535 --destination-port 33434:33523 \
-j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p icmp \
--icmp-type destination-unreachable -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p icmp \
--icmp-type port-unreachable -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p icmp \
--icmp-type time-exceed -j ACCEPT
Om één of andere voor mij duistere reden werkt dit soms niet. In dat geval valt de source-port niet in de 32769:65535 range, maar ergens in het 'unpriv' gebied (1024:65535).
Inkomende traceroute
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. Voor het toestaan van een traceroute vanaf een externe host dienen er bepaalde ICMP typen te worden toegestaan en er moet een range van UDP poorten worden opengezet.
iptables --table filter -A INPUT -i ppp0 -p udp \
--source-port 32769:65535 --destination-port 33434:33523 -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p icmp \
--icmp-type destination-unreachable -j ACCEPT
Masquerading
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. Wat masquerading inhoudt is in Masquerading al uitgelegd. Hieronder staan de rules waarmee dit mogelijk wordt gemaakt.
Ten eerste moet in de 'nat' table worden aangegeven dat er gemasquerade moet worden. Vervolgens moet het forwarden mogelijk worden gemaakt. Van het uitgaande verkeer is zeker dat de bron altijd een host in het interne netwerk is en het doel nooit in het interne netwerk ligt. Voor het inkomende verkeer geldt altijd het tegenovergestelde. Daarom kunnen in de forward rules de bron (-s) en doel (-d) worden opgegeven. In dit geval is '192.168.1.0/24' het adres van het interne netwerk. Om de hosts in het lokale netwerk gebruik te laten maken van de gateway dient deze te worden opgegeven in de netwerk instellingen.
iptables --table nat -A POSTROUTING -o ppp0 -j MASQUERADE
iptables --table filter -A FORWARD -i eth0 \
-o ppp0 -s 192.168.1.0/24 -d ! 192.168.1.0/24 -j ACCEPT
iptables --table filter -A FORWARD -o eth0 \
-i ppp0 -d 192.168.1.0/24 -s ! 192.168.1.0/24 \
-m state --state ESTABLISHED,RELATED -j ACCEPT
Gnomemeeting
Gnomemeeting gebruikt een vrij lastig te masqueraden protocol en vereist daarom een aantal extra regels. Met onderstaande regels kunnen alle mogelijkheden van Gnomemeeting gebruikt worden. Maar er kan slecht 1 computer in het interne netwerk gebruikt worden voor Gnomemeeting, omdat het IP adres van die computer in de firewall ge-'hardcode' moet worden. In onderstaande voorbeeld is '192.168.1.2' de computer waarop Gnomemeeting gebruikt wordt.
iptables --table nat -A PREROUTING -i ppp0 -p tcp \
--dport 30000:30010 -j DNAT --to-dest 192.168.1.2
iptables --table nat -A PREROUTING -i ppp0 -p tcp \
--dport 5000:5003 -j DNAT --to-dest 192.168.1.2
iptables --table filter -A FORWARD -i ppp0 -p tcp \
--dport 30000:30010 -d 192.168.1.2 -j ACCEPT
iptables --table filter -A FORWARD -i ppp0 -p tcp \
--dport 5000:5003 -d 192.168.1.2 -j ACCEPT
iptables --table nat -A PREROUTING -i ppp0 -p tcp \
--dport 1702 -j DNAT --to-dest 192.168.1.2
iptables --table filter -A FORWARD -i ppp0 -p tcp \
--dport 1702 -d 192.168.1.2 -j ACCEPT
TCP server openstellen
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. Alle algemeen voorkomende servers (ssh, http, smtp, pop3, imap, enz) maken gebruik van normale TCP connecties. De regels die hiervoor gebruikt kunnen worden zijn identiek aan de regels voor het toestaan van uitgaande TCP connecties, alleen dan andersom. Enige uitbreiding hierop is dat tevens het doel poortnummer kan worden meegegeven. En het bron poortnummer, want een TCP connectie wordt door een client (bv een webbrowser) gestart vanaf een ongeprivileerde poort (tussen 1024 en 65535).
In het onderstaande voorbeeld worden de regels gedemonstreerd zoals die voor een ssh (poort tcp/22) server gebruikt kunnen worden. Voor andere servers dient alleen de poort waarop de server luistert te worden gewijzigd.
Ten eerste de rules die nodig zin om het opzetten van de connectie mogelijk te maken:
iptables --table filter -A INPUT -i ppp0 -p tcp --source-port 1024:65535
--destination-port 22 --tcp-flags SYN,ACK,RST,FIN SYN \
-m state --state NEW -j ACCEPT
iptables --table filter -A OUTPUT -o ppp0 -p tcp --source-port 22
--destination-port 1024:65535 \
--tcp-flags SYN,ACK,RST,FIN SYN,ACK \
-m state --state ESTABLISHED,RELATED -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p tcp --source-port 1024:65535
--destination-port 22 --tcp-flags SYN,ACK,RST,FIN ACK \
-m state --state ESTABLISHED,RELATED -j ACCEPT
Als de connectie bestaat is er nog een regel nodig om datatransport mogelijk te maken:
iptables --table filter -A OUTPUT -o ppp0 -p tcp --source-port 22
--destination-port 1024:65535 --tcp-flags SYN,ACK,RST,FIN ACK \
-m state --state ESTABLISHED,RELATED -j ACCEPT
Voor het verbreken van de connectie zijn de volgende regels noodzakelijk:
iptables --table filter -A OUTPUT -o ppp0 -p tcp --source-port 22
--destination-port 1024:65535 \
--tcp-flags SYN,ACK,RST,FIN ACK,FIN \
-m state --state ESTABLISHED,RELATED -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p tcp --source-port 1024:65535
--destination-port 22 --tcp-flags SYN,ACK,RST,FIN ACK,FIN \
-m state --state ESTABLISHED,RELATED -j ACCEPT
Om een eventueel verstoorde connectie te herstellen is het noodzakelijk om pakketten waarvan alleen de "RST" flag geset is toe te staan in beide richtingen:
iptables --table filter -A OUTPUT -o ppp0 -p tcp \
--tcp-flags SYN,RST,FIN RST \
-m state --state ESTABLISHED,RELATED -j ACCEPT
iptables --table filter -A INPUT -i ppp0 -p tcp \
--tcp-flags SYN,RST,FIN RST \
-m state --state ESTABLISHED,RELATED -j ACCEPT
UDP server openstellen
In dit voorbeeld wordt ervan uit gegaan dat de default policy DROP is. Niet alle servers werken met alleen TCP. Bijvoorbeeld een nameserver verstuurt ook data over UDP. De regels hiervoor lijken op de regels voor het uitgaande UDP verkeer, maar dan in omgekeerde richting:
iptables --table filter -A INPUT -i ppp0 -p udp \
--destination-port 53 -m limit --limit 10/minute \
--limit-burst 20 -j ACCEPT
iptables --table filter -A OUTPUT -o ppp0 -p udp \
--source-port 53 -m state --state ESTABLISHED -j ACCEPT
Om 'Denial of Service' attacks te overleven kan het aantal op te zetten connecties gelimiteerd worden met 'limit'.
Gereserveerde netwerken uitsluiten
De IANA (organisatie die ipadresen uitdeelt) heeft bepaalde ranges van ipadressen gereserveerd voor speciale toepassingen. Zo zijn er bijvoorbeeld de Class A/B/C/D/E adressen die nooit op het openbare internet mogen voorkomen en alleen voor interne netwerken gebruikt mogen worden.
Sommige servers zijn alleen bedoelt voor interne netwerken (bijvoorbeeld gedeelde directories). Wanneer een host hier gebruik van wil maken wordt soms alleen het ipadres van die host gecontroleerd. Met een techniek die 'spoofing' heet kan hier misbruik van worden gemaakt. Dan doet een externe host zich voor als een host in het lokale netwerk door z'n ware ipadres te vervangen door een gereseveerd ipadres. Deze vorm van misbruik kan voorkomen worden door verkeer vanaf de externe interface waarvan het bron adres een gereserveerd adres is te blokkeren.
iptables --table filter -A INPUT -i ppp0 --source 10.0.0.0/8 -j DROP iptables --table filter -A INPUT -i ppp0 --source 172.16.0.0/12 -j DROP iptables --table filter -A INPUT -i ppp0 --source 192.168.0.0/16 -j DROP iptables --table filter -A INPUT -i ppp0 --source 224.0.0.0/4 -j DROP iptables --table filter -A INPUT -i ppp0 --source 240.0.0.0/5 -j DROP
Naast de Class A..E netwerken is er nog een aantal ipadressen gereserveerd voor speciale toepassingen:
RESERVED_NET="
0.0.0.0/8 1.0.0.0/8 2.0.0.0/8 \
5.0.0.0/8 \
7.0.0.0/8 \
23.0.0.0/8 \
27.0.0.0/8 \
31.0.0.0/8 \
36.0.0.0/8 37.0.0.0/8 \
39.0.0.0/8 \
41.0.0.0/8 42.0.0.0/8 \
49.0.0.0/8 50.0.0.0/8 \
58.0.0.0/8 59.0.0.0/8 \
70.0.0.0/8 71.0.0.0/8 72.0.0.0/8 73.0.0.0/8 \
74.0.0.0/8 75.0.0.0/8 76.0.0.0/8 77.0.0.0/8 78.0.0.0/8 79.0.0.0/8 \
89.0.0.0/8 90.0.0.0/8 91.0.0.0/8 92.0.0.0/8 93.0.0.0/8 94.0.0.0/8 \
95.0.0.0/8 96.0.0.0/8 97.0.0.0/8 98.0.0.0/8 99.0.0.0/8 100.0.0.0/8 101.0.0.0/8 \
102.0.0.0/8 103.0.0.0/8 104.0.0.0/8 105.0.0.0/8 106.0.0.0/8 107.0.0.0/8 \
108.0.0.0/8 109.0.0.0/8 110.0.0.0/8 111.0.0.0/8 112.0.0.0/8 113.0.0.0/8 \
114.0.0.0/8 115.0.0.0/8 116.0.0.0/8 117.0.0.0/8 118.0.0.0/8 119.0.0.0/8 \
120.0.0.0/8 121.0.0.0/8 122.0.0.0/8 123.0.0.0/8 124.0.0.0/8 125.0.0.0/8 \
126.0.0.0/8 127.0.0.0/8 \
173.0.0.0/8 174.0.0.0/8 175.0.0.0/8 176.0.0.0/8 177.0.0.0/8 178.0.0.0/8 \
179.0.0.0/8 180.0.0.0/8 181.0.0.0/8 182.0.0.0/8 183.0.0.0/8 184.0.0.0/8 \
185.0.0.0/8 186.0.0.0/8 187.0.0.0/8 189.0.0.0/8 190.0.0.0/8 \
197.0.0.0/8 \
223.0.0.0/8 \
240.0.0.0/8 241.0.0.0/8 242.0.0.0/8 243.0.0.0/8 244.0.0.0/8 245.0.0.0/8 \
246.0.0.0/8 247.0.0.0/8 248.0.0.0/8 249.0.0.0/8 250.0.0.0/8 251.0.0.0/8 \
252.0.0.0/8 253.0.0.0/8 254.0.0.0/8 255.0.0.0/8"
for NET in ${RESERVED_NET} ; do
iptables --table filter -A INPUT -i ppp0 --source ${NET} -j DROP
done
Deze lijst wordt regelmatig gewijzigd. Het is dus belangrijk om deze lijst regelmatig bij te werken. De officiele lijst met gereserveerde netwerken is te vinden als INTERNET PROTOCOL V4 ADDRESS SPACE.
Onmogelijke combinaties van tcp-flags blokkeren
Sommige portscanners gebruiken onmogelijke combinaties van tcp-flags voor bijvoorbeeld Xmas- of Null-scans. Met de onderstaande regels zijn deze scans te herkennen en kunnen ze direct geblokkeerd worden.
iptables --table filter -A INPUT -p tcp \
--tcp-flags ALL FIN,URG,PSH -j DROP
iptables --table filter -A INPUT -p tcp \
--tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
iptables --table filter -A INPUT -p tcp \
--tcp-flags ALL ALL -j DROP
iptables --table filter -A INPUT -p tcp \
--tcp-flags ALL NONE -j DROP
iptables --table filter -A INPUT -p tcp \
--tcp-flags SYN,RST SYN,RST -j DROP
iptables --table filter -A INPUT -p tcp \
--tcp-flags SYN,FIN SYN,FIN -j DROP
Redirecting
De 'REDIRECT' target is geschikt voor het doorlussen van de ene poort naar de andere op dezelfde host. Dat kan noodzakelijk zijn om bv pakketten voor http door te sturen naar een http proxy waardoor een volledig transparante proxy opgezet kan worden.
iptables -t nat -A PREROUTING -p tcp --dport 80 \
-j REDIRECT --to-port 8080
In dit voorbeeld is 192.168.1.4 de webserver in het interne netwerk die nu van buitenaf bereikbaar is.
Forwarding
Het is mogelijk om van binnenkomende pakketten de bestemming te wijzigen. Zo kunnen pakketten die binnenkomen op tcp/80 worden doorgestuurt naar een webserver die in het interne netwerkt draait.
iptables --table nat -A PREROUTING -i ppp0 -p tcp \
--dport 80 -j DNAT --to 192.168.1.4
In dit voorbeeld is 192.168.1.4 de webserver in het interne netwerk die nu van buitenaf bereikbaar is. Om dit te laten werken is het noodzakelijk om de 'FORWARD' regel welke wordt gebruikt bij 'masquerading' enigsinds aan te passen. De toevoeging '-m state --state RELATED,ESTABLISHED' dient verwijderd te worden.
Loggen
Tijdens het debuggen van een firewall is een goede logfunctionaliteit geen overbodige luxe. Als de firewall goed werkt kan een (beperkte) logfile ook interessant zijn. Voor het loggen van pakketten wordt de 'LOG' target gebruikt:
iptables --table filter -A INPUT -j LOG --log-prefix "inkomend pakket "
Nieuwe chains toevoegen
Soms kan het handig zijn om extra chains aan te maken waar bepaalde connecties naar doorgestuurd kunnen worden. Na het aanmaken van een nieuwe chain, kan de naam van deze chain als 'target' worden opgegeven. In het hieronderstaande voorbeeld worden alle bestaande connecties doorgegeven aan de "EXTRACHAIN".
iptables --table filter -N EXTRACHAIN iptables --table filter -A INPUT -m state --state ESTABLISHED -j EXTRACHAIN
iptables-save en iptables-restore
Een normale iptables installatie bevat "iptables-save" en "iptables-restore". Deze commando's zijn ter vervanging van een zelfgeschreven script. Met "iptables-save" kunnen alle ingevoerde regels in een bestand worden opgeslagen.
iptables-save > ~/iptables-regels
Vervolgens kunnen deze opgeslagen regels met het commando "iptables-restore" weer worden hersteld (bv na een reboot).
iptables-restore < ~/iptables-regels
Meestal is een zelfgeschreven script handiger dan gebruik maken van iptables-save en iptables-restore, omdat het overzichtelijker en flexibeler is.
Kant-en-klare NetFilter scripts
Hier stonden ooit een paar voorbeeldscripts ter illustratie. Nu niet meer.
FAQ
Waar zijn andere informatiebronnen mbt NetFilter en iptables te vinden?
- iptables manpage, de manual voor iptables.
- The iptables-HOWTO, waarin het gebruik van iptables zeer gedetaileerd wordt beschreven.
- Iptables Tutorial, te vinden op http://www.iptables.org/documentation/index.html
- The NAT-HOWTO, waarin NAT wordt beschreven.
- Iptables Tutorial van Oskar Andreasson http://iptables-tutorial.frozentux.net/iptables-tutorial.html
- netfilter-hacking-HOWTO, voor als je er echt geen genoeg van kan krijgen :)
Dit verhaal gaat over iptables. Ehhh, what about ipchains?
Ik ben me pas in firewalls gaan verdiepen toen de 2.4 kernel uit was. En die werkt met iptables. Van ipchains weet ik wel iets, en in grote lijnen komt het overeen met iptables, maar voor specifieke vragen moet je niet bij mij zijn. Een zeer goed verhaal over ipchains is de ipchains-HOWTO die op vrijwel elke LDP-mirror te vinden is. Voor een goede ipchains firewall kan je eens kijken op http://www.quarantine.de/
Bij de eerste regel krijg ik allemaal foutmeldingen over modules
Je heb geen iptables-support in je kernel. Lees het hoofdstuk over 'Kernel'. Voor meer informatie over het bouwen van een nieuwe kernel: Kernel-HOWTO.
FTP werkt niet
Lees het stukje over 'Modules' nog eens. Echter, onthoudt wel dat FTP een achterhaald en onveilig protocol is voor het versturen van bestanden. Een beter alternatief is scp: Secure CoPy.
MSN werkt niet
Dat zal best. Ik heb geen MSN. Ik weet niks van MSN. En dat wil ik graag zo houden. Ik weet wel hoe je Gnomemeeting door een masquerading firewall heenloodst.
iptables kan niet worden gevonden
Dan heb je iptables niet geinstalleerd. Lees de documentatie van je Linux distributie over hoe je iptables kan installeren.
M'n beeldscherm staat vol met log meldingen
Meestal zijn er twee logdaemons op een Linux systeem; syslogd en klogd. De NetFilter meldingen komen direct van de kernel en worden dus afgehandeld door klogd. Bij het starten van klogd (dat gebeurd normaal gesproken tijdens het booten) kun met de "-c" optie aangeven hoe ernstig een melding moet zijn voordat ie direct op het scherm wordt weergegeven. Bij sommige distro's worden meldingen van prioriteit "WARNING" en hoger direct naar de tty gestuurd. En dat is de prioriteit die NetFilter meldingen standaard ook meekrijgen. Oplossing hiervoor is dus om de waarde van de "-c" optie te wijzigen: "-c 4". Kijk ook eens in de manpage van klogd. Bij moderne uitvoeringen van logdaemons zoals bv syslog-ng is dit gewoon in de syslog configuratiefile te regelen.
Er verschijnt niks in m'n logfiles
Normaal hebben NetFilter meldingen de priority "warning" en behoren ze tot de facility "kernel". Hoe je er voor zorgt dat deze meldingen in de juiste logfile verschijnen kan je nalezen in de manpage van je log daemon.
Moet ik alle regels in een script zetten of kan het ook op de commandline?
Het is prima mogelijk om een paar regeltjes direct op de commandline in te tikken. Maar of dat ook handig betwijfel ik. Als je alles in een script zet is het veel eenvoudig om later te achterhalen wat je precies gedaan hebt en fouten kunnen makkelijker verbeterd worden.
Hoe kan ik m'n (zelfgemaakte) firewall testen
Beste manier is om vanaf een externe host een portscan te starten (bv nmap). Als er geen beschikking is over een externe host dan zijn er meerdere webbased portscanners beschikbaar. Nadeel van deze portscanners is dat ze vaak maar een zeer beperkt aantal poorten scannen. Ff googlen voor een lijstje met online portscanners.