Unix-/Linux Netz

Netzwerk der Schulung

• Die WAN-IP wird die 172.22.1.(100 + eigene Nr.)
• Die Demilitarisierte Zone (DMZ) enthält Services, die von außen erreichbar sein sollen
• Im LAN befindet sich unser Administratorrechner von dem wir unsere Rechner konfigurieren
• Das LAN soll Verbindungen ins Internet initiieren können, aber nicht direkt von außen erreichbar sein

[Bearbeiten]

xx in den folgenden Bildern durch die eigene Nummer ersetzen

Benutzername für virtuelle Maschinen ist xinux oder root

Passwort ist immer 123Start$

Labor Tag 1

[Bearbeiten]

Vorbereiten der Firewall als Router

• Wir klonen den Rechner "debian-server" und nennen ihn "Firewall"
• Dieser braucht 3 Netzwerkadapter:

1. Netzwerkbrücke
2. Internes Netzwerk "LAN"
3. Internes Netzwerk "DMZ"

• Wir starten die Firewall und konfigurieren statische IP Adressen für alle 3 Netzwerkadapter
• vim /etc/network/interfaces

auto lo
iface lo inet loopback

auto enp0s3
iface enp0s3 inet static
 address 172.22.1.1xx/16
 gateway 172.22.1.1

auto enp0s8
iface enp0s8 inet static
 address 192.168.0.1/24

auto enp0s9
iface enp0s9 inet static
 address 10.0.1.1xx.1/24

• Interfaces runter und wieder hochfahren, um die neue Konfiguration zu laden
• ifdown -va
• ifup -va
• Danach sollte der Befehl ip address show (oder ip a) die neuen IP Adressen anzeigen

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1456 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 08:00:27:9b:79:a1 brd ff:ff:ff:ff:ff:ff
    inet 172.22.1.1xx/16 brd 172.22.255.255 scope global enp0s3
       valid_lft forever preferred_lft forever
    inet6 2003:e5:173a:c401:a00:27ff:fe9b:79a1/64 scope global dynamic mngtmpaddr 
       valid_lft 7134sec preferred_lft 1215sec
    inet6 fe80::a00:27ff:fe9b:79a1/64 scope link 
       valid_lft forever preferred_lft forever
3: enp0s8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 08:00:27:15:03:b7 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.1/24 brd 192.168.0.255 scope global enp0s8
       valid_lft forever preferred_lft forever
    inet6 fe80::a00:27ff:fe15:3b7/64 scope link 
       valid_lft forever preferred_lft forever
4: enp0s9: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 08:00:27:31:01:09 brd ff:ff:ff:ff:ff:ff
    inet 10.0.1xx.1/24 brd 10.0.100.255 scope global enp0s9
       valid_lft forever preferred_lft forever
    inet6 fe80::a00:27ff:fe31:109/64 scope link 
       valid_lft forever preferred_lft forever

• Im Moment verwirft die Firewall alle Pakete mit IP-Adressen, die nicht für ihn selbst bestimmt sind
• Um die Pakete uns Default-Gateway weiterzuleiten muss der Kernelparameter net.ipv4.ip_forward gesetzt sein
• Temporär (bleibt nicht nach einem Reboot):
  • sysctl -w net.ipv4.ip_forward=1 # Einschalten
  • sysctl -w net.ipv4.ip_forward=0 # Ausschalten
• Für eine persistente Konfiguration muss dieser Parameter in der die Datei /etc/sysctl.conf stehen
• vim /etc/sysctl.conf

...

# Uncomment the next line to enable packet forwarding for IPv4
net.ipv4.ip_forward=1
...

• sysctl -p

net.ipv4.ip_forward = 1

• Source Network Address Translation muss noch geschehen, damit die Pakete mit IP Adressen aus einem privaten Netzwerk den Weg zurück finden
• vim /etc/nftables.conf

#!/usr/sbin/nft -f

flush ruleset

table inet filter {
    chain input {
        type filter hook input priority 0;
    }
    chain forward {
        type filter hook forward priority 0;
    }
    chain output {
        type filter hook output priority 0;
    }
}

table inet nat {
    chain postrouting {
        type nat hook postrouting priority 100; policy accept;
        oif enp0s3 masquerade
    }
}

• systemctl restart nftables
• systemctl enable nftables

Workstation im LAN zum Systemadministrator machen

• Den Netzwerkadapter von VM "arch-grafisch" auf "Internes Netzwerk LAN" umstellen und die VM starten
• Wenn wir unsere Netzwerkkonfiguration anschauen, dann sehen wir keine IP Adresse, da noch kein DHCP läuft
• Deshalb geben wir uns eine temporäre IP, um per SSH auf die Firewall zu kommen
• ip address add 192.168.0.2/24 dev enp0s3
• Nun können wir die Firewall per SSH erreichen
• ssh xinux@192.168.0.1
• als erstes ändern wir den hostnamen der Firewall von debian zu firewall
• hostnamectl set-hostname firewall
• vim /etc/hosts

127.0.0.1 localhost
127.0.1.1 firewall
...

• Ein erneutes einloggen updatet den Namen im Prompt
• als nächstes installieren wir einen DHCP Server, um Rechnern im LAN automatisch eine Netzwerkkonfiguration zu geben
• apt install isc-dhcp-server
• Am Ende der Installation wird es eine Fehlermeldung geben, da systemd versucht den Dienst zu starten, obwohl noch keine Konfiguration da ist
• vim /etc/default/isc-dhcp-server

DHCPDv4_CONF=/etc/dhcp/dhcpd.conf
INTERFACESv4="enp0s8"

• vim /etc/dhcp/dhcpd.conf

option domain-name-servers 1.1.1.1;
default-lease-time 600;
max-lease-time 7200;
authoritative;

subnet 192.168.0.0 netmask 255.255.255.0 {
    range 192.168.0.50 192.168.0.100;
    option routers 192.168.0.1;
}

# Feste IP-Adresse für eine bestimmte MAC-Adresse
host controller {
    hardware ethernet MAC Adresse vom Arch;
    fixed-address 192.168.0.2;
    option routers 192.168.0.1;
}

• Dienst mit der neuen Konfiguration starten und überprüfen
• systemctl restart isc-dhcp-server
• systemctl status isc-dhcp-server
• Beim Neustart von Arch sollte dann automatisch die 192.168.179.2 bekommen (falls nicht MAC-Adresse überprüfen)

SSH Schlüssel für passwortloses Login

• Um nicht jedes mal das Passwort beim Login eingeben zu müssen kann man sich stattdessen mit einem privaten Schlüssel authentifizieren
• Wir erstellen einen Schlüssel mit RSA Verschlüsselung und erstmal ohne Passwortabfrage für den Benutz des Schlüssels
• ssh-keygen # Einfach mit Enter alles bestätigen
• scp ~/.ssh/id_rsa.pub xinux@192.168.0.1:~/.ssh/authorized_keys
• In der authorized_keys Datei können mehrere öffentliche Schlüssel stehen (pro Zeile ein Schlüssel)
• Es ist üblich SSH Login über Passwörter komplett auszuschalten sobald die SSH Schlüssel von den zugangsberechtigten Benutzern hinterlegt sind

Labor Tag 2

[Bearbeiten]

DNS Server

• Ein Klon von "debian-server" mit Netzwerkadapter im internen Netzwerk "DMZ" erstellen
• IP Adresse in /etc/network/interfaces konfigurieren: 10.0.(100 + eigene Nr.).254
• Zurück zu Arch wechseln und über SSH auf den DNS Server einloggen
• ssh xinux@10.0.(100 + eigene Nr.).254
• sudo su
• Hostname auf DNS: setzen (in /etc/hosts auch umändern)
• SSH Schlüssel hinterlegen
• Bind9 installieren
• vim /etc/resolv.conf

nameserver 1.1.1.1

• apt install bind9
• vim /etc/resolv.conf

nameserver 127.0.0.1

Optionen festlegen

• vim /etc/bind/named.conf.options

options {
        directory "/var/cache/bind";
        dnssec-validation no;
        allow-recursion { 0.0.0.0/0; };
};

Zone definieren

• vim /etc/bind/named.conf.local

zone "lab(100 + eigene Nr.).it" {
        type master;
        file "lab(100 + eigene Nr.).it";
};

Zonendatei erstellen

• vim /var/cache/bind/lab(100 + eigene Nr.).it

$TTL 300
@       IN SOA  dns.lab(100 + eigene Nr.).it. technik.xinux.de. ((Datum + Ver.nr.) 14400 3600 3600000 86400)
        IN NS   dns
dns     IN A    10.0.(100 + eigene Nr.).254
fw      IN A    10.0.(100 + eigene Nr.).1

statische Routen zu den anderen DMZs eintragen

• Im Moment kennt unsere Firewall nicht die Route zu den anderen DNS Servern
• vim /etc/network/interfaces

enp0s3 inet static
 address 172.22.1.100/16
 gateway 172.22.1.1
 post-up ip route add 10.0.100.0/24 via 172.22.1.100
 post-up ip route add 10.0.101.0/24 via 172.22.1.101
 ...

Auflösen anderer Domänen über eine Pseudo Top Level Domain

Dienst neustarten und DNS-Auflösung testen

• systemctl restart bind9
• dig +short dns.lab(100 + eigene Nr.).it
• dig +short xinux.net
• Wenn das funktioniert dann den DNS Server im DHCP Server als Standard DNS Server und Suchdomäne eintragen (zur Firewall wechseln)
• vim /etc/dhcp/dhcpd.conf

option domain-name "lab(100 + eigene Nr.).it";
option domain-name-servers 10.0.(100 + eigene Nr.).254;
...

• systemctl restart isc-dhcp-server
• Arch neustarten und in /etc/resolv.conf nachschauen, ob die neue Konfiguration automatisch gezogen wurde

Bind9 Forwarder eintragen

• Wenn jeder die DMZ der anderen erreichen kann, ist es möglich über eine Top Level Domain die anderen Domänen aufzulösen
• Dazu muss man auf den DNS Server einen vorkonfigurierten Pseudo Top Level Domain Nameserver als Forwarder eintragen
• vim /etc/bind/named.conf.options

...
forwarders { 10.0.100.254; }; //IP des Top Level Domain Nameservers
...

• Wenn man die Reverse Zone später auch auflösen will braucht man diese Zeile
• vim /etc/bind/named.conf.options

...
empty-zones-enable no;
...

• systemctl restart bind9
• Einmal alle Domänen durchtesten
• dig +short dns.lab1xx.it
• ping fw.lab1xx.it

Reverse Lookup

• Für manche Dienste muss einer IP einen Domain Namen zugeordnet werden
• Dazu eine neue Zone definieren und eine neue Zonendatei erstellen
• vim /etc/bind/named.conf.local

zone "100.0.10.in-addr.arpa" {
        type master;
        file "100.0.10.in-addr.arpa";
};

• vim 100.0.10.in-addr.arpa

$TTL 300
@       IN SOA  dns.lab100.it. technik.xinux.de. (2023050901 14400 3600 3600000 86400)
        IN NS   dns.lab100.it.
1       IN PTR  fw.lab100.it.
254     IN PTR  dns.lab100.it.

• systemctl restart bind9

Netz absichern

• Im Moment darf jeder auf die Firewall von jeden zugreifen (und damit alle dahinterliegenden Systeme)
• Um dies zu verhindern erstellen wir mit nftables Firewall Regeln, die nur das nötigste zulassen
• Die Regeln werden von oben nach unten abgearbeitet
• Wenn keine Regel greift, dann zieht die Default Policy

Prerouting, Input, Forward, Output und Postrouting sind Punkte an denen wir Regeln erstellen können

[Bearbeiten]

Nur SSH aus LAN auf die Firewall zulassen

• Default Policy wird in allen Filterketten auf Drop gesetzt
• Wenn also keine Regel das Paket durchlässt, wird es verworfen
• Über Connection Tracking können wir uns auf die Regulierung neuer Verbindungen fokussieren
• Als erstes soll nur:
  • Die Firewall mit sich selbst über das loopback Interface kommunizieren können (da es sonst zu komischen Problemen führen kann)
  • Etablished und Related Pakete akzeptiert werden
  • Neue Anfragen aus dem LAN auf TCP Port 22 akzeptieren
  • Firewall soll über HTTP bzw. HTTPS Programme herunterladen können
  • Gedroppte Pakete sollen geloggt werden
• vim /etc/nftables.conf

#!/usr/sbin/nft -f

flush ruleset
define wandev = enp0s3
define landev = enp0s8
define lan = 192.168.0.0/24

table inet filter {
        chain input {
                type filter hook input priority filter; policy drop;
                iif "lo" accept
                ct state established,related accept
                iif $landev tcp dport 22 accept
                log prefix "--nftables-drop-input--"
        }
        chain forward {
                type filter hook forward priority filter; policy drop;
                ct state established,related accept
                log prefix "--nftables-drop-forward--"
        }
        chain output {
                type filter hook output priority filter; policy drop;
                ct state established,related accept
                oif $wandev tcp dport { 80, 443 } accept
                log prefix "--nftables-drop-output--"
        }

table inet nat {
        chain postrouting {
                type nat hook postrouting priority srcnat; policy accept;
                oif $wandev masquerade
        }
}

• systemctl restart nftables

Connection Tracking Tabelle

• Das Tool conntrack installieren, um die CTT anschauen und leeren zu können
• apt install conntrack
• conntrack -F # Leert die Tabelle
• conntrack -L

tcp      6 432000 ESTABLISHED src=192.168.0.2 dst=192.168.0.2 sport=58178 dport=22 src=192.168.0.1 dst=192.168.0.2 sport=22 dport=58178 [ASSURED] mark=0 use=1

DNS, HTTP(S)

• Rechnern im LAN sollen Webseiten aufrufen können
• unsere DNS Server sollten andere Server im Internet und in den anderen DMZs befragen dürfen
• d.h. UDP Port 53 aus LAN und DMZ und TCP Ports 80 und 443 für LAN sollten freigeschalten werden
• vim /etc/nftables.conf

#!/usr/sbin/nft -f

flush ruleset
define wandev = enp0s3
define landev = enp0s8
define dmzdev = enp0s9
define lan = 192.168.0.0/24
define dmz = 10.0.1xx.0/24

table inet filter {
        chain input {
                type filter hook input priority filter; policy drop;
                iif "lo" accept
                ct state established,related accept
                iif $landev tcp dport 22 accept
                log prefix "--nftables-drop-input--"
        }
        chain forward {
                type filter hook forward priority filter; policy drop;
                ct state established,related accept
                iif { $dmzdev, $landev } ip saddr { $dmz, $lan } udp dport 53 oif { $dmzdev, $wandev } accept
                iif $landev ip saddr $lan tcp dport { 80, 443 } oif $wandev accept
                log prefix "--nftables-drop-forward--"
        }
        chain output {
                type filter hook output priority filter; policy drop;
                ct state established,related accept
                oif $wandev tcp dport { 80, 443 } accept
                log prefix "--nftables-drop-output--"
        }

table inet nat {
        chain postrouting {
                type nat hook postrouting priority srcnat; policy accept;
                oif $wandev masquerade
        }
}

Destination NAT und Portforwarding

• Ein Webserver in der DMZ soll öffentlich erreichbar sein
• Das Internet kennt aber nur unsere WAN IP
• Wir erwarten, dass solche Anfragen auf Port 80/443 an unsere Firewall ankommen
• Die Zieladresse soll dann in der Prerouting Kette auf die des Webserver umgeschrieben werden
• Dadurch geht das Paket in die Forward Kette anstatt der Input Kette
• Also muss dort die entsprechende Regel zum Freischalten stehen

#!/usr/sbin/nft -f

flush ruleset
define wandev = enp0s3
define landev = enp0s8
define dmzdev = enp0s9
define lan = 192.168.0.0/24
define dmz = 10.0.1xx.0/24
define wanip = 172.22.1.1xx
define webserver = 10.0.1xx.254

table inet filter {
        chain input {
                type filter hook input priority filter; policy drop;
                iif "lo" accept
                ct state established,related accept
                iif $landev tcp dport 22 accept
                log prefix "--nftables-drop-input--"
        }
        chain forward {
                type filter hook forward priority filter; policy drop;
                ct state established,related accept
                iif { $dmzdev, $landev } ip saddr { $dmz, $lan } udp dport 53 oif { $dmzdev, $wandev } accept
                iif $landev ip saddr $lan tcp dport { 80, 443 } oif $wandev accept
                ip daddr $webserver tcp dport 80 accept
                log prefix "--nftables-drop-forward--"
        }
        chain output {
                type filter hook output priority filter; policy drop;
                ct state established,related accept
                oif $wandev tcp dport { 80, 443 } accept
                log prefix "--nftables-drop-output--"
        }

table inet nat {
        chain prerouting {
                type nat hook prerouting priority 0; policy accept;
                ip daddr $wanip tcp dport 80 dnat ip to $webserver:80
        }

        chain postrouting {
                type nat hook postrouting priority srcnat; policy accept;
                oif $wandev masquerade
        }
}

• systemctl restart nftables
• Der DNS Server soll uns erstmal auch als Webserver dienen
• apt install apache2
• Im Browser sollten die Webserver über die IPs der Firewalls erreichbar sein

Debug Möglichkeiten

• Falls sich die Firewall nicht so verhält wie erwartet, kann man:
  • Connection Tracking Tabelle leeren/flushen: conntrack -F
  • Über tail -f -n0 /var/log/syslog | grep nftables gedroppte Pakete anschauen (wenn die Log Regeln da sind)
  • NAT Regeln überprüfen: tcpdump -i interface filter
  • Auf Syntaxfehler überprüfen: nft -f /etc/nftables.conf

Labor Tag 3

[Bearbeiten]

• LDAP
• Openldap Basic Config common

Labor Tag 4

[Bearbeiten]

Labor Tag 5

[Bearbeiten]