Cover
Aloita nyt ilmaiseksi LSS - Lecture IV - Linux firewalling.pdf
Summary
# Introductie tot firewalls en hun functionaliteit
Dit gedeelte introduceert het concept van een firewall, de oorsprong van de term en de functie ervan in netwerkbeveiliging, en legt de basis voor de latere discussie over specifieke firewalltechnologieën en hun plaats in het OSI-model [3](#page=3).
### 1.1 Wat is een firewall?
Een firewall is een netwerkbeveiligingssysteem dat inkomend en uitgaand netwerkverkeer controleert en regelt op basis van vooraf bepaalde beveiligingsregels. De term "firewall" vindt zijn oorsprong in een muur die oorspronkelijk bedoeld was om een brand in aangrenzende gebouwen te beperken. In netwerkbeveiliging functioneert een firewall als een barrière tussen een vertrouwd intern netwerk en een onvertrouwd extern netwerk, zoals het internet [3](#page=3).
### 1.2 Firewalling op verschillende lagen van het OSI-model
Firewalls kunnen opereren op verschillende lagen van het Open Systems Interconnection (OSI) model. Het OSI-model bestaat uit zeven lagen: Fysiek (Layer 1), Datalink (Layer 2), Netwerk (Layer 3), Transport (Layer 4), Sessie (Layer 5), Presentatie (Layer 6) en Applicatie (Layer 7) [5](#page=5).
#### 1.2.1 Netwerkfirewalls
Netwerkfirewalls opereren voornamelijk op de netwerk- en transportlagen van het OSI-model. Ze inspecteren netwerkpakketten op basis van informatie zoals IP-adressen en poortnummers [5](#page=5) [7](#page=7).
* **Netwerkgebaseerde netwerkfirewalls** bevinden zich op gateways voor meerdere hosts en inspecteren de pakketten die zij moeten doorsturen. Ze kunnen bestaan uit speciale hardware of software op algemene hardware. Voorbeelden hiervan zijn Cisco, Netgate, netfilter/iptables, pfSense [7](#page=7).
* **Hostgebaseerde netwerkfirewalls** bevinden zich op een enkele host en inspecteren zowel inkomende als uitgaande pakketten. Ze draaien vaak als een daemon of service. Voorbeelden zijn netfilter/iptables en Windows Defender Firewall [7](#page=7).
#### 1.2.2 Applicatiefirewalls
Applicatiefirewalls, ook wel bekend als next-generation firewalls (NGFW), opereren op hogere lagen van het OSI-model, met name de applicatielaag. Ze voeren inspectie uit van de inhoud van de data, voorbij de basispakketinformatie die netwerkfirewalls gebruiken [5](#page=5) [6](#page=6).
* **Netwerkgebaseerde applicatiefirewalls** bevinden zich op gateways voor meerdere hosts en fungeren vaak als een (reverse) proxy. Ze zijn specifiek voor bepaalde applicatieprotocollen en voeren contentinspectie uit, bijvoorbeeld op virussen of exploits. Voorbeelden zijn Web Application Firewalls (WAF), ModSecurity (Modsec) en Cloudflare's Cloud WAF [6](#page=6).
* **Hostgebaseerde applicatiefirewalls** draaien op een enkele host en bieden sandboxing voor meerdere applicaties. Next-generation firewalls maken hierbij vaak gebruik van Mandatory Access Control (MAC). Voorbeelden zijn AppArmor en SELinux [6](#page=6).
### 1.3 Samenwerking tussen firewalls
Een applicatiefirewall werkt complementair aan een netwerkfirewall. De netwerkfirewall wordt vaak beschouwd als de eerste verdedigingslinie en is vaak ingebouwd in het besturingssysteem. Dit gelaagde beveiligingsmodel biedt een meer robuuste bescherming door verschillende aspecten van het netwerkverkeer op verschillende niveaus te inspecteren en te controleren [8](#page=8).
---
# Netfilter en iptables in Linux
Dit deel van de studiehandleiding behandelt Netfilter, de ingebouwde netwerkfirewall van Linux, en de bijbehorende gebruikersruimte-tool iptables. We duiken dieper in de architectuur van Netfilter, inclusief tabellen, chains en hooks, en demonstreren hoe iptables wordt gebruikt voor het configureren van regels [9](#page=9).
### 2.1 Introductie tot Netfilter
Netfilter is een stateful packet-filtering firewall die sinds kernelversie 2.4 deel uitmaakt van de Linux kernel. Het werd ontwikkeld door Paul “Rusty” Russell en is een fundamenteel onderdeel van de netwerkbeveiliging in Linux. De oorspronkelijke documentatie beschrijft de ontwikkeling als een "grote strijd en heldhaftige daden" met als doel "de derde leeftijd van Linux firewalling" in te luiden [12](#page=12).
Netfilter is meer dan alleen iptables; het is een framework dat op verschillende niveaus kan worden benaderd. Naast iptables zijn er ook andere gebruikersruimte-tools zoals `nft / nftables`, `xtables`, en oudere tools zoals `ip6tables`, `arptables`, en `ebtables` die specifiek waren voor IPv6, ARP en Ethernet-frames [10](#page=10).
> **Tip:** Onthoud dat Netfilter een kernelcomponent is, terwijl iptables een gebruikersruimte-tool is om deze te configureren.
### 2.2 Architectuur van Netfilter
De kern van Netfilter bestaat uit tabellen, chains en regels [13](#page=13).
#### 2.2.1 Tabellen
Netfilter organiseert zijn functionaliteit in verschillende tabellen, elk met een specifiek doel:
* **filter**: Dit is de standaardtabel en wordt gebruikt voor algemene pakketfiltering [16](#page=16).
* **nat**: Deze tabel wordt geraadpleegd wanneer een pakket wordt aangetroffen dat een nieuwe verbinding creëert, en wordt gebruikt voor Netwerkadresvertaling (NAT) [16](#page=16).
* **mangle**: Een speciale tabel die kan worden gebruikt voor het aanpassen van pakketten [16](#page=16).
* **raw**: Dit is de tabel met de hoogste prioriteit en wordt aangeroepen vóór alle andere tabellen. Het wordt voornamelijk gebruikt voor uitzonderingen in connection tracking [16](#page=16).
* **security**: Deze tabel wordt gebruikt voor verplichte toegangscontrole netwerkregels (Mandatory Access Control), zoals die ingeschakeld door `SECMARK` en `CONNSECMARK` targets [16](#page=16).
Tabelnamen worden in kleine letters geschreven [18](#page=18).
#### 2.2.2 Chains
Binnen elke tabel bevinden zich chains, die fungeren als logische groepen van regels. Netfilter heeft vijf belangrijke "hooks" in de netwerkstack van de Linux kernel, die corresponderen met vijf iptables chains [14](#page=14):
1. **PREROUTING**: Voor pakketten zodra ze binnenkomen in het netwerkapparaat [14](#page=14).
2. **INPUT**: Voor pakketten die bestemd zijn voor lokale sockets op de machine zelf [14](#page=14).
3. **FORWARD**: Voor pakketten die via de machine worden gerouteerd naar een andere bestemming [14](#page=14).
4. **OUTPUT**: Voor pakketten die lokaal worden gegenereerd door processen op de machine [14](#page=14).
5. **POSTROUTING**: Voor pakketten vlak voordat ze het systeem verlaten, na routingbeslissingen [14](#page=14).
Chains worden in hoofdletters geschreven [18](#page=18).
> **Tip:** De `PREROUTING` en `POSTROUTING` chains worden gebruikt voor pakketten die door de machine worden gerouteerd (niet bestemd voor de machine zelf), terwijl `INPUT` en `OUTPUT` worden gebruikt voor verkeer dat de lokale machine betreft. De `FORWARD` chain is specifiek voor pakketten die worden doorgestuurd [15](#page=15).
#### 2.2.3 Hooks en Packet Flow
De packet filtering "hooks" zijn de punten in de Linux kernel netwerkstack waar Netfilter pakketten kan inspecteren en manipuleren. Een gedetailleerd overzicht van de packet flow toont hoe pakketten door de verschillende tabellen en chains gaan, afhankelijk van hun oorsprong en bestemming [14](#page=14) [19](#page=19).
> **Example:** Een inkomend pakket dat bestemd is voor de lokale machine zal de `PREROUTING` hook passeren, vervolgens de `filter` tabel doorlopen (indien van toepassing) en uiteindelijk de `INPUT` chain bereiken. Een pakket dat lokaal wordt gegenereerd, doorloopt de `OUTPUT` chain en kan daarna de `POSTROUTING` chain passeren voordat het het netwerk verlaat [19](#page=19).
### 2.3 De iptables Tool
`iptables` is de gebruikersruimte-applicatie die wordt gebruikt om de regels in de Netfilter kernelmodules te configureren [10](#page=10).
#### 2.3.1 Huidige regels bekijken
Om de momenteel geconfigureerde regels te bekijken, gebruikt men de `iptables -L` commando. Optioneel kan men met de `-t` vlag een specifieke tabel specificeren, bijvoorbeeld `iptables -t raw -L` om de regels in de `raw` tabel te tonen. Standaard toont `iptables -L` de regels van de `filter` tabel [23](#page=23).
> **Example:**
> ```bash
> sudo iptables -L
> ```
> Dit commando toont de chains `INPUT`, `FORWARD` en `OUTPUT` met hun standaard policies en eventuele regels [23](#page=23).
#### 2.3.2 Standaard Policies (Default Policy)
Elke chain heeft een standaard policy die bepaalt wat er met pakketten gebeurt die niet door een specifieke regel worden gematcht. Veelvoorkomende policies zijn `ACCEPT` (doorgelaten) en `DROP` (stilletjes genegeerd) [24](#page=24).
> **Tip:** Het is een goede beveiligingspraktijk om de default policy van de `FORWARD` en `INPUT` chains in te stellen op `DROP` en alleen expliciet benodigde verkeer toe te staan [24](#page=24).
> **Example:**
> ```bash
> sudo iptables -P FORWARD DROP
> ```
> Dit commando stelt de standaard policy van de `FORWARD` chain in op `DROP`, wat betekent dat al het verkeer dat bedoeld is om te worden doorgestuurd, standaard wordt geweigerd [24](#page=24).
#### 2.3.3 Firewallregels toevoegen
Regels kunnen worden toegevoegd aan chains met de `-A` (append) of `-I` (insert) opties [25](#page=25).
* **Append (`-A`)**: Voegt een regel toe aan het einde van een chain [25](#page=25).
> **Example:** `iptables -A FORWARD -j LOG` voegt een regel toe aan het einde van de `FORWARD` chain die al het verkeer logt [25](#page=25).
* **Insert (`-I`)**: Voegt een regel in op een specifieke positie binnen een chain [25](#page=25).
> **Example:** `iptables -I FORWARD 3 -j LOG` voegt een regel toe als de derde regel in de `FORWARD` chain [25](#page=25).
#### 2.3.4 Targets
Een target bepaalt de actie die wordt uitgevoerd op een pakket dat aan de regels voldoet. Veelgebruikte targets zijn [26](#page=26):
* **ACCEPT**: Sta het pakket toe [26](#page=26).
* **DROP**: Negeer het pakket stilzwijgend [26](#page=26).
* **REJECT**: Sta het pakket niet toe en stuur een foutmelding terug naar de afzender [26](#page=26).
* **LOG**: Log het pakket voor analyse, maar laat het daarna doorgaan naar het volgende target [26](#page=26).
#### 2.3.5 Regelcriteria
Regels specificeren criteria waaraan een pakket moet voldoen om gematcht te worden. Belangrijke criteria zijn [27](#page=27):
* `-s` of `--source`: Bronadres of netwerk [27](#page=27).
* `-d` of `--destination`: Bestemmingsadres of netwerk [27](#page=27).
* `-p` of `--protocol`: Het protocol (bv. `tcp`, `udp`, `icmp`) [27](#page=27).
Daarnaast kunnen modules worden gebruikt voor meer gedetailleerde matching. Raadpleeg `man iptables` en `man iptables-extensions` voor een volledig overzicht [27](#page=27).
> **Example:**
> ```bash
> iptables -A INPUT -s 192.168.1.0/24 -p icmp -j ACCEPT
> ```
> Deze regel staat ICMP-verkeer toe vanaf het netwerk `192.168.1.0/24` naar de `INPUT` chain [27](#page=27).
> **Example met module:**
> ```bash
> iptables -A INPUT -s 192.168.111.100 -p icmp -m length --length 200:1500 -j DROP
> ```
> Deze regel dropt ICMP-pakketten van het adres `192.168.111.100` met een lengte tussen 200 en 1500 bytes, die de `INPUT` chain bereiken [27](#page=27).
#### 2.3.6 Firewallregels verwijderen
Het verwijderen van regels is een kritiek onderdeel van het beheer van de firewall [28](#page=28).
* **Regelnummers weergeven**: Gebruik `iptables -L --line-numbers` om regels met hun nummers te zien [28](#page=28).
* **Specifieke regel verwijderen**: Gebruik de `-D` (delete) optie met het chain- en regelnummer [28](#page=28).
> **Example:** `iptables -D FORWARD 3` verwijdert de derde regel uit de `FORWARD` chain [28](#page=28).
* **Alle regels in een chain verwijderen**: Gebruik de `-F` (flush) optie [28](#page=28).
> **Example:** `iptables -F FORWARD` verwijdert alle regels uit de `FORWARD` chain [28](#page=28).
* **Alle regels in alle chains van een tabel verwijderen**: Gebruik de `-F` optie zonder chain specificatie voor de standaard (filter) tabel [28](#page=28).
> **Example:** `iptables -F` verwijdert alle regels uit alle chains van de `filter` tabel [28](#page=28).
#### 2.3.7 Waarschuwingen
Wees extreem voorzichtig bij het configureren van iptables, vooral via SSH. Een verkeerde commando kan ervoor zorgen dat u permanent buitengesloten wordt totdat de machine fysiek wordt benaderd [29](#page=29).
> **Warning:** Configureer altijd eerst de regels die toegang verlenen tot de server (bijvoorbeeld SSH-toegang) voordat u andere regels instelt die mogelijk de toegang kunnen blokkeren. Test wijzigingen grondig en houd een fallback-methode beschikbaar [29](#page=29).
---
# Nieuwere firewalltechnologie: nftables
Dit gedeelte introduceert nftables als de opvolger van iptables, met een focus op de nieuwe kernel-backend (nf_tables) en de bijbehorende gebruikersruimte-tool nft, waarbij de voordelen, verschillen en syntax worden besproken [30](#page=30).
### 3.1 Introductie tot nftables
Nftables is de moderne opvolger van iptables en maakt gebruik van de nieuwe kernel-backend `nf_tables`, wat staat voor Netfilter. Het hergebruikt de bestaande hook-infrastructuur van Netfilter, de zogenaamde "chains". Nftables is beschikbaar in de Linux kernel vanaf versie 3.13 en wordt beheerd door de `nft` gebruikersruimte-tool. Een significant verschil is de introductie van een nieuwe, meer compacte syntax. Hoewel de nieuwe syntax de voorkeur heeft, kan de oude iptables-syntax nog steeds worden gebruikt en wordt deze vertaald naar de `nf_tables` backend [31](#page=31).
### 3.2 Voordelen van nftables ten opzichte van iptables
Nftables biedt verschillende verbeteringen ten opzichte van iptables:
* **Verbeterde prestaties**: Sneller pakketclassificatie wordt mogelijk gemaakt [33](#page=33).
* **Betere ondersteuning voor dynamische regelaanpassingen**: Het bijwerken van regelsets is efficiënter [33](#page=33).
* **Uniforme syntax**: Adres, protocol en extensiespecifieke inconsistenties van iptables worden aangepakt, wat leidt tot een nettere en compactere syntax [33](#page=33).
* **Universele tool**: Met `nft` kunnen alle adresfamilies (IPv4, IPv6, ARP, etc.) worden beheerd, wat de afzonderlijke tools zoals `iptables`, `ip6tables` en `arptables` vervangt [33](#page=33).
* **Vereenvoudigd dual-stack beheer**: De nieuwe `inet` familie maakt het beheer van zowel IPv4 als IPv6 gemakkelijker [33](#page=33).
### 3.3 Nftables in distributies
Vanaf Red Hat Enterprise Linux (RHEL) 8 gebruikt het `iptables`-commando de `nf_tables` backend, wat betekent dat de oude iptables-syntax wordt vertaald naar de nieuwe nftables-backend. Dit is te controleren met commando's als `which iptables` en `realpath USD(which iptables)` [34](#page=34).
In Debian 11 is het `iptables`-commando niet langer standaard geïnstalleerd. De `nft`-commando is de voorgeschreven methode voor firewallbeheer [35](#page=35).
> **Tip:** Controleer welke firewall-backend uw systeem gebruikt, vooral bij het migreren van oudere configuraties. Op moderne systemen is de kans groot dat `iptables` een alias is voor de `nftables` backend.
### 3.4 Nftables syntax: tabellen, chains en regels
De configuratie in nftables is gestructureerd rond tabellen, chains en regels.
#### 3.4.1 Tabellen (tables)
Een tabel specificeert de adresfamilie waarvoor de regels gelden. De veelvoorkomende families zijn [36](#page=36):
* `ip`: voor IPv4. Komt overeen met het oude `iptables` [36](#page=36).
* `ip6`: voor IPv6. Komt overeen met het oude `ip6tables` [36](#page=36).
* `inet`: voor zowel IPv4 als IPv6. Dit is een nieuwe familie die het beheer van dual-stack vereenvoudigt [33](#page=33) [36](#page=36).
* `arp`: voor ARP-pakketten. Komt overeen met het oude `arptables` [36](#page=36).
* `bridge`: voor bridge-filtering. Komt overeen met `ebtables` [36](#page=36).
* `netdev`: maakt gebruik van de nieuwe `ingress`-hook [36](#page=36).
Als er geen familie wordt gespecificeerd, is de standaardfamilie `ip` [36](#page=36).
**Voorbeeld:** Een tabel aanmaken met de `inet` familie: `nft add table inet mytable` [36](#page=36).
#### 3.4.2 Chains
Chains zijn collecties van regels. Er zijn twee types [37](#page=37):
* **Base chain**: Deze wordt gekoppeld aan de netwerkstack via hooks en heeft parameters als `type`, `hook` en `priority` [37](#page=37).
* **Regular chain**: Deze worden voornamelijk gebruikt voor een betere organisatie van regels [37](#page=37).
**Parameters van Base Chains:**
* **Type**: Definieert het doel van de chain. Veelvoorkomende types zijn `filter` (standaard packet filtering), `nat` (voor Network Address Translation) en `route` (voor route lookup) [38](#page=38).
* `filter`: Kan gebruikt worden met alle families en hooks [38](#page=38).
* `nat`: Kan gebruikt worden met `ip`, `ip6` en `inet` families voor specifieke hooks [38](#page=38).
* `route`: Kan gebruikt worden met `ip` en `ip6` families voor de `output` hook [38](#page=38).
* **Hook**: Specificeert in welke fase van de pakketverwerking de chain actief wordt. De hooks zijn [39](#page=39):
* `ingress`: Een nieuwe hook die beschikbaar is sinds kernel 4.2 via `nf_tables`, waarmee pakketten al zeer vroeg in de netwerkstack kunnen worden gefilterd. Dit biedt een vroeg detectiepunt voor verkeer [40](#page=40).
* `prerouting`: Verwerking voor de routeringsbeslissing [39](#page=39).
* `input`: Pakketten bestemd voor de lokale machine [39](#page=39).
* `forward`: Pakketten die door de machine heen gerouteerd worden [39](#page=39).
* `output`: Pakketten die door de machine zelf worden gegenereerd [39](#page=39).
* `postrouting`: Verwerking na de routeringsbeslissing [39](#page=39).
> **Tip:** De `ingress`-hook is krachtig omdat het alle verkeer voor een NIC ziet, zonder aannames over L2/L3 protocollen, wat zeer vroege filtering mogelijk maakt [40](#page=40).
* **Priority**: Een integerwaarde die de volgorde van chains op dezelfde hook bepaalt. Lagere prioriteitswaarden hebben voorrang. Standaard prioriteitsnamen, die de volgorde aangeven, zijn: `raw` < `mangle` < `dstnat` < `filter` < `security` < `srcnat` [42](#page=42).
**Voorbeeld:** Een base chain aanmaken: `nft add chain inet mytable mychain { type filter hook input priority filter \; policy accept \; }` [37](#page=37).
#### 3.4.3 Regels (rules)
Regels worden opgebouwd uit twee componenten: expressies en statements [43](#page=43).
* **Expressies**: Bepalen wat er gematcht moet worden [43](#page=43).
* **Statements**: Definiëren de actie die ondernomen moet worden bij een match [43](#page=43).
**Voorbeeld van een regel:** `nft add rule inet mytable mychain tcp dport {80, 443} ct state new,established counter accept`. Deze regel accepteert TCP-verkeer naar poorten 80 en 443, telt het verkeer mee (`counter`) en markeert het als nieuw of gevestigd (`ct state new,established`) [43](#page=43).
### 3.5 Commando's en beheer
De `nft` tool biedt een reeks commando's voor het beheren van tabellen, chains en regels [44](#page=44).
* **Tabellen:**
* `nft list tables []`: Toon tabellen [44](#page=44).
* `nft list table [] [-n [-a]`: Toon specifieke tabel [44](#page=44).
* `nft (add | delete | flush) table [] `: Voeg toe, verwijder of wis een tabel [44](#page=44).
* **Chains:**
* `nft (add | create) chain []