Unix-/Linux Netz

Netzwerk der Schulung

Anpassung der Virtuellen Maschine UNIX/LINUX Netz

• Die WAN-IP wird die 172.RNr.0.(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$

Vorbereiten der Firewall

[Bearbeiten]

• Wir klonen den Rechner "Server Vorlage" 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.RNr.0.1xx/16
 gateway 172.RNr.1.1

auto enp0s8
iface enp0s8 inet static
 address 192.168.0.1/24

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

• Interfaces runter und wieder hochfahren, um die neue Konfiguration zu laden
• ifdown -va
• ifup -va
• bzw.
• systemctl restart networking
• 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.RNr.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

Workstation im LAN zum Systemadministrator machen

• Den Netzwerkadapter von VM "LAN Host" 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
• systemctl stop NetworkManager
• 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
• sudo -i
• hostnamectl set-hostname fwxx
• vim /etc/hosts

127.0.0.1 localhost
127.0.1.1 fwxx 
...

• 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 Debian sollte dann automatisch die 192.168.0.2 bekommen (falls nicht MAC-Adresse überprüfen)

Firewall als Router konfigurieren

• 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

SSH Schlüssel für passwortloses Login

LAN

• 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 # 123Start$ als Passwort nehmen
• ssh-copy-id xinux@192.168.0.1
• bzw.
• 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
• Normalerweise sind die Schlüssel passwortgeschützt.
• Damit man nicht jedes mal das Passwort dafür eingeben muss kann man einen SSH Agent nutzen

Firewall

• Wir wollen uns direkt als root einloggen können, weshalb die authorized_keys Datei auch im Home-Verzeichnis des root-Nutzers liegen muss
• sudo -i
• mkdir .ssh
• cp ~xinux/.ssh/authorized_keys .ssh/
• Um den SSH-Server abszusichern können wir den Port verlegen und nur schlüsselbasiertes Einloggen zulassen
• vim /etc/ssh/sshd_config

Port 2222
AddressFamily inet
ListenAddress 192.168.0.1
PubkeyAuthentication yes
PasswordAuthentication no
UsePAM no

• systemctl restart sshd

LAN

• Nun sollten wir uns direkt als root anmelden können
• ssh -p 2222 root@192.168.0.1 "id && hostname"
• Um die Ameldung einfacher zu gestalten können wir unseren SSH-Client konfigurieren
• vim ~/.ssh/config

Host fwxx
	Hostname 192.168.0.1
	User root
	Port 2222

• Jetzt kann man den Befehl folgendermaßen verkürzen:
• ssh fwxx

DHCP erweitern

• Um neue Rechner in der DMZ automatisch über LAN administrierbar zu machen, erweitern wir den DHCP Server auf der Firewall
• vim /etc/default/isc-dhcp-server

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

• Die Subnetzdefinitionen folgen der Reihenfolge der Interfaces in /etc/default/isc-dhcp-server
• vim /etc/dhcp/dhcpd.conf

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;
}

subnet 10.0.1xx.0 netmask 255.255.255.0 {
   range 10.0.1xx.50 10.0.1xx.100;
   option routers 10.0.1xx.1;
}

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

• systemctl restart isc-dhcp-server

DNS Server

[Bearbeiten]

Virtualbox

• Ein Klon von "Server Vorlage" mit Netzwerkadapter im internen Netzwerk "DMZ" erstellen
• Über die Systemlogs für DHCP auf der Firewall können wir die IP Adresse des DNS-Servers herausfinden

Firewall

• journalctl -u isc-dhcp-server
• Zurück zu Debian wechseln und über SSH auf den DNS Server einloggen
• ssh xinux@10.0.(100 + eigene Nr.). yy

DNS

• Anschließend die IP Adresse in /etc/network/interfaces konfigurieren: 10.0.(100 + eigene Nr.).2
• Hostname auf DNS dns.lab1xx.nux 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.).nux" {
        type master;
        file "lab(100 + eigene Nr.).nux";
};

Zonendatei erstellen

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

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

• Dienst neustarten und testen
• systemctl restart bind9
• dig +short dns.lab1xx.nux
• dig +short fw.lab1xx.nux

Destination NAT und Portforwarding

• Der DNS-Server in der DMZ soll öffentlich erreichbar sein
• Das Internet kennt aber nur unsere WAN IP
• Wir erwarten, dass solche Anfragen auf Port 53 UDP/TCP 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 wanip = 172.RNr.0.1xx 
define dnsserver = 10.0.1xx.2

table inet filter {
        chain input {
                type filter hook input priority filter;
        }
        chain forward {
                type filter hook forward priority filter;
        }
        chain output {
                type filter hook output priority filter;
        }
}
table inet nat {
        chain prerouting {
                type nat hook prerouting priority -100; policy accept;
                ip daddr $wanip tcp dport 53 dnat ip to $dnsserver:53
                ip daddr $wanip udp dport 53 dnat ip to $dnsserver:53
        }

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

• systemctl restart nftables

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.).nux
• 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.).nux";
option domain-name-servers 10.0.(100 + eigene Nr.).2;
...

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

Bind9 Forwarder eintragen

DNS Server der .nux-Domain

• 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 { 172.RNr.0.100; }; //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.nux
• ping fw.lab1xx.nux

Pseudo .nux Domain Server

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

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

• Zur Zonendefinition hinzufügen
• vim /etc/bind/named.conf.local

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

• Zonendateien
• vim /var/cache/bind/nux

$TTL 300
@       IN      SOA     dns.nux. technik.xinux.de. (2023041809 14400 3600 3600000 86400)

@       IN      NS      dns.nux.
lab101          NS      dns.lab101.nux.
lab102          NS      dns.lab102.nux.
lab100          NS      dns.nux.

dns     IN      A       172.RNr.0.100
dns.lab101      A       172.RNr.0.1xx
dns.lab102      A       172.RNr.0.1xy

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 "1XX.0.10.in-addr.arpa" {
        type master;
        file "1XX.0.10.in-addr.arpa";
};

• vim /var/cache/bind/1XX.0.10.in-addr.arpa

$TTL 300
@       IN SOA  dns.lab1XX.nux. technik.xinux.de. (2023050901 14400 3600 3600000 86400)
        IN NS   dns.lab1XX.nux.
1       IN PTR  fw.lab1XX.nux.
2       IN PTR  dns.lab1XX.nux.

• 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)
  • Established und Related Pakete akzeptiert werden
  • Neue Anfragen aus dem LAN auf TCP Port 2222 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 wanip = 172.RNr.0.1xx 
define dnsserver = 10.0.1xx.2
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 2222 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;
		oif "lo" accept
		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 -100; policy accept;
		ip daddr $wanip tcp dport 53 dnat ip to $dnsserver:53
		ip daddr $wanip udp dport 53 dnat ip to $dnsserver:53
	}

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

• systemctl restart nftables

Internetzugriff für LAN und Firewall

• vim /etc/nftables.conf

#!/usr/sbin/nft -f

flush ruleset

define wanip = 172.22.0.1xx
define dnsserver = 10.0.1xx.2
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 0; policy drop;
		ct state { "established", "related" } accept
		iif "lo" accept
		iif $landev ip saddr $lan tcp dport 2222 accept
		icmp type echo-request accept
		log prefix "--nftables-drop-input--"
	}
	chain forward {
		type filter hook forward priority 0; policy drop;
		ct state { "established", "related" } accept
		icmp type echo-request accept
		iif $landev ip saddr $lan oif $dmzdev ip daddr $dnsserver udp dport 53 accept
		iif $wandev ip daddr $dnsserver tcp dport 53 accept
		iif $wandev ip daddr $dnsserver udp dport 53 accept
		iif $dmzdev ip saddr $dnsserver tcp  dport 53 accept
		iif $dmzdev ip saddr $dnsserver udp dport 53 accept
		oif $wandev tcp dport { 80, 443 } accept
               iif $dmzdev ip saddr $dmz oif $wandev tcp dport { 80, 443 } accept
               iif $dmzdev ip saddr $dmz oif $wandev icmp type echo-request accept
		iif $landev ip saddr $lan oif $dmzdev ip daddr $dmz tcp dport 22 accept
		log prefix "--nftables-drop-forward--"
	}
	chain output {
		type filter hook output priority 0; policy drop;
		ct state { "established", "related" } accept
		icmp type echo-request accept
		udp dport 53 accept
		oif $wandev tcp dport { 80, 443 } accept
		log prefix "--nftables-drop-output--"
	}
}

table inet nat {
	chain prerouting {
		type nat hook prerouting priority -100; policy accept;
                ip daddr $wanip tcp dport 53 dnat ip to $dnsserver:53
                ip daddr $wanip udp dport 53 dnat ip to $dnsserver:53
	}
	chain postrouting {
		type nat hook postrouting priority 100; policy accept;
		oif $wandev masquerade
	}
}

• systemctl restart nftables

Mit Kommentar

#!/usr/sbin/nft -f

flush ruleset
define wanip = 172.22.0.113
define dnsserver = 10.0.113.2
define wandev = enp0s3
define landev = enp0s8
define dmzdev = enp0s9
define lan = 192.168.0.0/24
define dmz = 10.0.113.0/24

table inet filter {
	chain input {
		type filter hook input priority 0; policy drop;
		ct state { "established", "related" } accept
		#Interne Kommunikation von Linux 
		iif "lo" accept
		#Erlaubt Zugriff per SSH aufs LAN Interface
		iif $landev ip saddr $lan tcp dport 2222 accept
		#Erlaubt Pings
		icmp type echo-request accept
		#Zusatz Logs
		log prefix "--nftables-drop-input--"
	}
	chain forward {
		type filter hook forward priority 0; policy drop;
		ct state { "established", "related" } accept
		icmp type echo-request accept
		#Zugriff vom Lan Netz nach DMZ nur für die IP vom DNS Server und Port 53
		iif $landev ip saddr $lan oif $dmzdev ip daddr $dnsserver udp dport 53 accept
		#Zugriff vom WAN für die IP DNS Port 53 TCP
		iif $wandev ip daddr $dnsserver tcp dport 53 accept
		#Zugriff vom WAN für die IP DNS Port 53 UDP
		iif $wandev ip daddr $dnsserver udp dport 53 accept
		#Zugriff vom DMZ für die IP DNS Port 53 TCP
		iif $dmzdev ip saddr $dnsserver tcp  dport 53 accept
		#Zugriff vom DMZ für die IP DNS Port 53 UDP
		iif $dmzdev ip saddr $dnsserver udp dport 53 accept
		#Zugriff Ins WAN (Internet) für Port 80 / 443 (Web)	
		oif $wandev tcp dport { 80, 443 } accept
		#Zugriff Ins Wan für die DMZ für Port 80 / 443 (web)
		iif $dmzdev ip saddr $dmz oif $wandev tcp dport { 80, 443 } accept
		#Pngs erlaubt für die DMZ
                iif $dmzdev ip saddr $dmz oif $wandev icmp type echo-request accept
		#Zugriff vom Lan in die DMZ für ssh (Port 22)
		iif $landev ip saddr $lan oif $dmzdev ip daddr $dmz tcp dport 22 accept
		log prefix "--nftables-drop-forward--"
	}
	chain output {
		type filter hook output priority 0; policy drop;
		ct state { "established", "related" } accept
		icmp type echo-request accept
		udp dport 53 accept
		#Zugriff von der Firewall ins Internet
		oif $wandev tcp dport { 80, 443 } accept
		log prefix "--nftables-drop-output--"
	}
}

table inet nat {
	chain prerouting {
		type nat hook prerouting priority -100; policy accept;
               #Die Eingehende Verbindung vom WAN für port 53 die IP vom DNS Server bekommen
		ip daddr $wanip tcp dport 53 dnat ip to $dnsserver:53
                ip daddr $wanip udp dport 53 dnat ip to $dnsserver:53
	}
	chain postrouting {
		type nat hook postrouting priority 100; policy accept;
		# Ausgehende Verbindung ins Internet die IP vom WAN 
		oif $wandev masquerade
	}
}

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

Webserver

[Bearbeiten]

Virtuelle Maschine einrichten UNIX-/Linux Netz (WebServer)

• 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

Nginx

 #!/usr/sbin/nft -f

 flush ruleset

 define wanip = 172.22.0.1xx
 define dnsserver = 10.0.1xx.2
 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 0; policy drop;
		ct state { "established", "related" } accept
		iif "lo" accept
		iif $landev ip saddr $lan tcp dport 2222 accept
		icmp type echo-request accept
		log prefix "--nftables-drop-input--"
     }
     chain forward {
         type filter hook forward priority filter; policy drop;
         ct state established,related accept
         icmp type echo-request accept
         iif $landev ip saddr $lan oif $dmzdev ip daddr $dnsserver udp dport 53 accept
         iif $wandev ip daddr $dnsserver tcp dport 53 accept
         iif $wandev ip daddr $dnsserver udp dport 53 accept
         iif $dmzdev ip saddr $dnsserver tcp  dport 53 accept
         iif $dmzdev ip saddr $dnsserver udp dport 53 accept
         oif $wandev tcp dport { 80, 443 } accept
         iif $dmzdev ip saddr $dmz oif $wandev tcp dport { 80, 443 } accept
         iif $dmzdev ip saddr $dmz oif $wandev icmp type echo-request accept
         iif $landev ip saddr $lan oif $dmzdev ip daddr $dmz tcp dport 22 accept
         '''iif $landev ip saddr $lan tcp dport { 80, 443 } oif $dmzdev accept'''
         log prefix "--nftables-drop-forward--"
     }
     chain output {
         type filter hook output priority filter; policy drop;
         ct state established,related accept
         icmp type echo-request accept
         udp dport 53 accept
         oif $wandev tcp dport { 80, 443 } accept
         log prefix "--nftables-drop-output--"
     }
 }
 table inet nat {
	chain prerouting {
		type nat hook prerouting priority -100; policy accept;
                ip daddr $wanip tcp dport 53 dnat ip to $dnsserver:53
                ip daddr $wanip udp dport 53 dnat ip to $dnsserver:53
	}
	chain postrouting {
		type nat hook postrouting priority 100; policy accept;
		oif $wandev masquerade
	}
}

Verschlüsseln

sudo apt update
sudo apt install openssl

openssl genpkey -algorithm RSA -out privkey.key -pkeyopt rsa_keygen_bits:2048
openssl genrsa -out privkey.key 2048

openssl req -new -key privkey.key -out certrequest.csr

openssl x509 -req -days 365 -in certrequest.csr -signkey privkey.key -out certificate.crt

NGINX

server {
    listen 443 ssl;
    server_name example.com; 


    ssl_certificate     /etc/nginx/ssl/certificate.crt;
    ssl_certificate_key /etc/nginx/ssl/privkey.key;


    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;


    root /var/www/html;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}


server {
    listen 80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

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 wanip = 172.22.0.1xx
define dnsserver = 10.0.1xx.2
define wandev = "enp0s3"
define landev = "enp0s8"
define dmzdev = "enp0s9"
define lan = 192.168.0.0/24
define dmz = 10.0.1xx.0/24
 '''define webserver = 10.0.1''xx''.3'''
 
 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
                 icmp type echo-request accept
                 iif $landev ip saddr $lan oif $dmzdev ip daddr $dnsserver udp dport 53 accept
                 iif $wandev ip daddr $dnsserver tcp dport 53 accept
                 iif $wandev ip daddr $dnsserver udp dport 53 accept
                 iif $dmzdev ip saddr $dnsserver tcp  dport 53 accept
                 iif $dmzdev ip saddr $dnsserver udp dport 53 accept
                 oif $wandev tcp dport { 80, 443 } accept
                 iif $dmzdev ip saddr $dmz oif $wandev tcp dport { 80, 443 } accept
                 iif $dmzdev ip saddr $dmz oif $wandev icmp type echo-request accept
                 iif $landev ip saddr $lan oif $dmzdev ip daddr $dmz tcp dport 22 accept
                 iif $landev ip saddr $lan tcp dport { 80, 443 } oif $dmzdev accept
                 '''ip daddr $webserver tcp dport { 80, 443} accept'''
                 log prefix "--nftables-drop-forward--"
         }
         chain output {
                 type filter hook output priority filter; policy drop;
                 ct state established,related accept
                 icmp type echo-request accept
                 udp dport 53 accept
                 oif $wandev tcp dport { 80, 443 } accept
                 log prefix "--nftables-drop-output--"
         }
 }
 table inet nat {
         '''chain prerouting {'''
                 '''type nat hook prerouting priority -100; policy accept;'''
                 ip daddr $wanip tcp dport 53 dnat ip to $dnsserver:53
                 ip daddr $wanip udp dport 53 dnat ip to $dnsserver:53
                 '''ip daddr $wanip tcp dport 80 dnat ip to $webserver:80'''
                 '''ip daddr $wanip tcp dport 443 dnat ip to $webserver:443'''
         '''}'''
 
         chain postrouting {
                 type nat hook postrouting priority 100; policy accept;
                 oif $wandev masquerade
         }
 }

• systemctl restart nftables

• 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 -cf /etc/nftables.conf

LDAP Server einrichten

[Bearbeiten]

• ein LDAP Server ermöglicht uns zentrale Benutzerverwaltung innerhalb einer Domäne
• die Benutzerdaten werden in einer Datenbank gespeichert und von Clients über TCP Port 389 befragt
• eine neue VM vom Template klonen und Grundeinstellungen vornehmen:

Virtuelle Maschine einrichten UNIX-/Linux Netz (LDAP)

• eventuell muss auf der Firewall Port 80 und 443 für die DMZ freigeschaltet werden, damit die Pakete heruntergeladen werden können
• LDAP
• Openldap-linux-pam-nss
• ldap client
• LDAP Client Einrichtung
• Openldap Basic Config common

SFTP zur sicheren Dateiübertragung

Virtuelle Maschine einrichten UNIX-/Linux Netz (SFTP)

HAProxy für zentrale SSL Terminierung

[Bearbeiten]

• eine neue VM vom Template klonen und Grundeinstellungen vornehmen:

Virtuelle Maschine einrichten UNIX-/Linux Netz (HAProxy)
Virtuelle Maschine einrichten UNIX-/Linux Netz (www2)

1. signiertes Wildcard-Zertifikat erstellen
2. privaten Zertifikatsschlüssel erstellen

openssl genrsa -out lab1xx.nux.key 2048
openssl req -new -key lab1xx.nux.key -out lab1xx.nux.csr

openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout lab1xx.nux.key -out lab1xx.nux.crt

• Auf dem HAProxy die server.pem Datei erstellen
• cat lab1xx.nux.key lab1xx.nux.crt > /etc/haproxy/server.pem
• vim /etc/haproxy/haproxy.cfg

HA Proxy HTTP

frontend https_web_services
 bind 10.0.1xx.2:443 name localhost_443 ssl crt /etc/haproxy/server.pem
 timeout client 50000
 mode http
 acl acl_web1 hdr_beg(host) -i web1
 acl acl_web2 hdr_beg(host) -i web2
 use_backend backend_web1 if acl_web1
 use_backend backend_web2 if acl_web2
 default_backend http_backend

#frontend https_frontend
# bind 10.0.1xx.2:443 name localhost_443 ssl crt /etc/haproxy/server.pem
# timeout client 50000
# default_backend http_backend

backend backend_web1
 timeout connect 5000
 timeout server 50000
 mode http
 server web_dns 10.0.1xx.2:80 check

backend backend_web2
 timeout connect 5000
 timeout server 50000
 mode http
 server web_ldap 10.0.1xx.3:80 check

backend http_backend
 mode http
 balance roundrobin
 timeout connect 5000
 timeout server 50000
 server web_dns_2 10.0.1xx.2:80 check
 server web_ldap_2 10.0.1xx.3:80 check

HAProxy HTTPS

frontend https_web_services
   bind 10.0.1xx.6:443 name localhost_443 ssl crt /etc/haproxy/server.pem
   timeout client 50000
   mode http
   acl acl_web1 hdr_beg(host) -i web1
   acl acl_web2 hdr_beg(host) -i web2
   use_backend backend_web1 if acl_web1
   use_backend backend_web2 if acl_web2
   default_backend http_backend

backend backend_web1
   timeout connect 5000
   timeout server 50000
   mode http
   server web1 10.0.1xx.3:443 ssl verify none check  

backend backend_web2
   timeout connect 5000
   timeout server 50000
   mode http
   server web2 10.0.1xx.4:443 ssl verify none check  

backend http_backend
   mode http
   balance roundrobin
   timeout connect 5000
   timeout server 50000
   server web1 10.0.1xx.3:443 ssl verify none check
   server web2 10.0.1xx.4:443 ssl verify none check

• systemctl restart haproxy

Squid Proxy auf der Firewall

• Virtuelle Maschine einrichten UNIX-/Linux Netz (Squid)
• Squid ACL Basic

• Mehr Kontrolle über die Domains, die LAN erreichen darf
• vim /etc/squid/squid.conf

acl facebook url_regex -i facebook

http_access deny facebook
http_access allow all

#nativer Zugriff
http_port 3128 ssl-bump cert=/etc/squid/certs/squid_proxyCA.pem generate-host-certificates=on options=NO_SSLv3,NO_TLSv1,NO_TLSv1_1,SINGLE_DH_USE,SINGLE_ECDH_USE
#transparenter Zugriff unverschlüsselt
http_port 3128 intercept
#transparenter Zugriff verschlüsselt wichtig https_port
https_port 3129 ssl-bump intercept cert=/etc/squid/certs/squid_proxyCA.pem generate-host-certificates=on options=NO_SSLv3,NO_TLSv1,NO_TLSv1_1,SINGLE_DH_USE,SINGLE_ECDH_USE

ssl_bump bump all

coredump_dir /var/spool/squid
logfile_rotate 0

cache_dir ufs /var/spool/squid 200 16 256

• vim /etc/squid/squid.conf

...
acl domain_blacklist dstdomain "/etc/squid/domain_blacklist.txt"
...
http_access deny all domain_blacklist
http_access allow localnet
...

• vim /etc/squid/domain_blacklist.txt

facebook.com
twitter.com

• systemctl restart squid

[Bearbeiten]

Festplatten verschlüsseln

Das Verschlüsseln mit cryptsetup löscht alle vorherigen Daten der Festplatte

• Neue Festplatte in VirtualBox erstellen und anhängen
• zu verschlüsselnde Partition anlegen
• fdisk /dev/sdX
• cryptsetup luksFormat /dev/sdXx
• cryptsetup open /dev/sdXx name
• Dateisystem auf der entschlüsselten Partition anlegen
• mkfs.ext4 /dev/mapper/name
• beliebige Testdatei erstellen
• echo "Hallo Welt" > encrypted.txt
• Nach Benutzen der Partition wieder verschlüsseln
• cryptsetup close name

Separate VM für Monitoring/Scanning

1. Hostname auf health setzen
2. statische IP vergeben 10.0.1xx.4/24
3. SSH Schlüssel hinterlegen
4. Eintrag im DNS Server vornehmen

Checkmk

Virtuelle Maschine bereitstellen UNIX-LINUX Netzwerke (checkmk)

• Die Weboberfläche soll über https://cmk.lab1xx.nux erreichbar sein:
  • DNS Eintrag
  • HAProxy ACL

• Download: https://checkmk.com/de/download?method=cmk&edition=cre&version=2.2.0b7&platform=debian&os=bullseye&type=cmk
• Anweisungen der Webseite folgen
• cmkadmin's Passwort auf 123Start$ ändern
• Rechner ins Monitoring hinzufügen
• AUR Paketmanager https://github.com/Jguer/yay