Ziel

physischer Netzwerkplan

[Bearbeiten]

logischer Netzwerkplan

[Bearbeiten]

[Bearbeiten]

VirtualBox Vorlage

Ein Debian 12 Server wurde mit Standardprogrammen vorbereitet
Die Vorlage liegt im pub-Ordner oder kann über SSH kopiert werden
scp 192.168.HS.200:~/Dokumente/vorlage.ova ~/Dokumente
Für neue Server sollte immer ein vollständinger Klon mit neuen MAC-Adressen erzeugt werden

Aufbau des Labors

Eine Debian Maschine soll uns als Firewall dienen
Diese soll über einen Bridgeadapter eine pseudo-öffentliche IP im Schulungsnetzwerk erhalten
Ein zweiter Netzwerkadapter vom Typ "internes Netzwerk" soll als LAN der Labore dienen
Nun muss die Netzwerkeinstellung wie im Schaubild konfiguriert werden:

[Bearbeiten]

Hostzugriff absichern

Falls man physischen Zugriff zur Maschine hat, kann die Authentifzierung von root beim Booten umgangen werden
Bootsicherheit/-hacking
Das wollen wir an der Firewall verhindern
GRUB Passwort einrichten

Remotezugriff mit SSH

Da man nicht immer physisch an einer Maschine anwesend sein kann, empfiehlt es sich Hosts über SSH zu steuern
Der Datenverkehr ist dabei verschlüsselt, damit es beide Maschinen vor potentiellen Angreifern schützt, die den Verkehr mitschneiden
Jeder Host soll über das SSH-Protokoll administrierbar sein
Generieren Sie einen SSH-Schlüssel mit der Passphrase, z.B. 123Start$
hinterlegen Sie den öffentlichen Schlüssel für die Nutzer kit und root auf der Firewall
Der SSH-Server sollte nach Sicherstellung des Zugriffs über autorisierte SSH-Schlüssel keine Passwort-Authentifizierung mehr zulassen: SSH-Server Hardening
Am Ende sollte jeder Host über ssh user@ip.oder.host.name erreichbar sein

Router Firewall

Hardwareanpassungen, damit die Dienste später auch genug Ressourcen haben:
- 4 GB RAM
- 4 CPUs
- 3 Netzwerkkarten
Als nächstes setzen wir den Hostnamen der äußeren Router Firewall und konfigurieren die statischen IP
hostnamectl set-hostname firewall
für die statische IP muss die Datei /etc/network/interfaces bearbeitet werden (Distributions abhängig)
vim /etc/network/interfaces

auto lo
iface lo inet loopback

auto enp0s3
iface enp0s3 inet static
 address 192.168.HS.1xx/24
 gateway 192.168.HS.254

auto enp0s8
iface enp0s8 inet static
 address 172.16.1xx.1/24
 post-up ip address add dev enp0s8 172.17.1xx.1/24

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

ifdown -va ; ifup -va
bzw.
systemctl restart networking
Als Kontrolle kann man ip addr show ausführen

Masquerade

Als nächstes muss noch IPv4 Forwarding und Masquerading aktiviert werden
nftables Masquerade
Für bessere Performance durch eine statische Tabelle kann man auch SNAT verwenden
nftables SNAT

Ports blockieren

Für den Anfang soll die Firewall nur SSH für unseren KIT Host zulassen
Zusätzlich sollte er auf Pings antworten und durchlassen, um Netzwerkanalyse zu vereinfachen
Wir werden die Regeln unter iptables umsetzen und schauen uns dann an wie nftables diesselben Regeln verarbeitet
apt install iptables
iptables Grundgerüst Firewall
nftables Grundgerüst Firewall
Beide Varianten sollen ausprobiert werden, aber wir werden hauptsächlich mit nftables arbeiten
Aufgabe: Zusätzlich zum Grundgerüst sollen die Firewall selbst noch grundlegende Funktionen wie Ping und Internetzugriff bekommen

DHCP

Damit Hosts im LAN automatisch eine IP-Adresse erlangen, konfigurieren wir nun einen DHCP Server (Befehle ab hier finden auf der Firewall statt!)
apt install isc-dhcp-server
Falls dieser Befehl einen Fehler in der Namensauflösung schmeist, dann muss ein richtiger Nameserver eingetragen werden
vim /etc/resolv.conf

nameserver 1.1.1.1 # Als Beispiel. Man kann auch jeden anderen validen Nameserver verwenden

Nach der Installation des DHCP Servers beschwert sich systemd, dass er den Dienst nicht starten kann, weil er noch nicht richtig konfiguriert ist.
Das ist nicht weiter schlimm, da wir ihn wie folgt einstellen:
vim /etc/default/isc-dhcp-server

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

vim /etc/dhcp/dhcpd.conf

option domain-name-servers 1.1.1.1;
default-lease-time 7200;

subnet 172.17.1xx.0 netmask 255.255.255.0 {
        range 172.17.1xx.50 172.17.1xx.100;
        option routers 172.17.1xx.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;
}

systemctl restart isc-dhcp-server.service

Switch

Für den Anfang erstellen nur einen einfachen Layer 2 Switch ohne jegliche Filterregeln
Dazu muss auf der Maschine bridge-utils installiert werden
apt install bridge-utils
Anschließend muss eine Bridge-Schnittstelle erstellt werden, die zwischen allen anderen realen Schnittstellen weiterleiten kann
vim /etc/network/interfaces

auto lo
iface lo inet loopback

auto enp0s3
iface enp0s3 inet manual

auto enp0s8
iface enp0s8 inet manual

auto enp0s9
iface enp0s9 inet manual
 
auto enp0s10
iface enp0s10 inet manual

auto br0
iface br0 inet static
 address 172.16.1xx.2/24
 gateway 172.16.1xx.1
 bridge_ports all

systemctl restart networking
Die IP-Konfiguration auf der Bridge ermöglicht Remote-Zugriff auf den Switch

Bridge Firewall

Auf dem Switch für das Admin-Netzwerk und das LAN werden Firewall-Regeln erstellt, die die Auflösung aus dem LAN in das Admin-Netzwerk verhindern sollen
vim /etc/nftables.conf

#!/usr/sbin/nft -f

flush ruleset

define admin_port = enp0s8
define lan = 172.17.1xx.0/24

table bridge bridge_filter {
	chain postrouting {
		type filter hook postrouting priority 0; policy accept;
		oif $admin_port arp saddr ip $lan log prefix "nftables drop ARP von LAN zu Admin-Netzwerk: " drop
	}
}

systemctl enable --now nftables

VLANs konfigurieren

Als Alternative zu Bridge Firewalls können VLANs konfiguriert werden
Dazu muss das Modul 8021q in den Linux-Kernel geladen werden
apt install vlan
modprobe 8021q
Für eine persistente Lösung sollte man das Modul in die Datei /etc/modules eintragen
vim /etc/modules

8021q

Ein Layer 2 Switch mit VLANs kann folgendermaßen konfiguriert werden: Linux Layer 2 VLAN Switch
Der DHCP-Server muss angepasst werden, damit die neuen Schnittstellen auch die Anfragen beantworten können
vim /etc/default/isc-dhcp-server

...
INTERFACES="enp0s8.2 enp0s9"

DNS für das Labor einrichten

[Bearbeiten]

Vorbereitungen

VirtualBox Server-Vorlage mit neuen MAC-Adressen klonen
Der Host soll im DMZ-Netzwerk liegen
IP-Adresse herausfinden über das DHCP-Log oder die Konsole
SSH-Schlüssel des Kit Hosts für User kit und root hinterlegen
statische IP-Adresse nach dem Netzwerkplan setzen (/etc/network/interfaces)
Hostname ändern zu dns
SSH-Server anpassen

lab1xx.sec

Die folgenden Befehle geschehen auf dem DNS Server
apt install bind9
dig ist ein praktisches Tool, um die DNS Auflösung zu testen
dig +short @127.0.0.1 xinux.net

194.59.156.162

Wenn das funktioniert hat, sollte man den Nameserver auf den lokalen Host setzen
vim /etc/resolv.conf

nameserver 127.0.0.1

Damit andere den Nameserver benutzen können, müssen die Antwort-Optionen angepasst werden
vim /etc/bind/named.conf.options

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

vim /etc/bind/named.conf.local

zone "lab1xx.sec" {
        type master;
        file "lab1xx.sec";
};

vim /var/cache/bind/lab1xx.sec

$TTL 300
@      IN SOA  dns.lab1xx.sec. technik.xinux.de. (2023041702 14400 3600 3600000 86400)
       IN NS   dns
dns    IN A    10.0.1xx.2
fw     IN A    192.168.HS.1xx
admin  IN A    172.16.1xx.10
...

Zonenkonfiguration

Nun wollen wir unsere eigenen Zonen definieren, wobei die Antwort davon abhängt aus welchem Netz die Anfrage kommt
vim /etc/bind/named.conf.local

acl intern { 172.16.1xx.0/24; 172.17.1xx.0/24; localhost; 10.0.1xx.0/24; };
acl extern { any; };

view intern {
	match-clients { intern; };
	zone "lab1xx.sec" {
		type master;
		file "intern/lab1xx.sec";
	};
};

view extern {
	match-clients { extern; };
	zone "lab1xx.sec" {
		type master;
		file "extern/lab1xx.sec";
	};
};

Die eigentliche Zuweisung von Name zu IP geschieht in den folgenden Dateien
vim /var/cache/bind/intern/lab1xx.sec

$TTL 300
@       IN SOA  dns.lab1xx.sec. technik.xinux.de. (2023041702 14400 3600 3600000 86400)
        IN NS   dns
dns     IN A    10.0.1xx.2
www     IN A    10.0.1xx.3
sftp	IN A    10.0.1xx.4
fw      IN A    192.168.HS.1xx

vim /var/cache/bind/extern/lab1xx.sec

$TTL 300
@       IN SOA  dns.lab1xx.sec. technik.xinux.de. (2023041702 14400 3600 3600000 86400)
        IN NS   dns
*       IN A    192.168.3.1xx

Portforwarding mit iptables

Damit andere den Namenserver in der DMZ befragen können, muss die Firewall ein Destination NAT auf UDP Port 53 durchführen
Hier ein Bespiel wie die Firewall aussehen könnte
vim /usr/local/sbin/firewall

#!/bin/bash

LANDEV="enp0s8"
DMZDEV="enp0s9"
WANDEV="enp0s3"
LAN="172.16.1xx.0/24"
DMZ="10.0.1xx.0/24"
WANIP="192.168.3.1xx"
DNSSERVER="10.0.1xx.2"

case $1 in
	start)
		echo "starte Firewall"
		iptables -F
		iptables -F -t nat

		iptables -P INPUT DROP
		iptables -A INPUT -i lo -j ACCEPT
		iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A INPUT -p tcp --dport 2222 -i $LANDEV -s $LAN -j ACCEPT
		iptables -A INPUT -p icmp --icmp-type echo-request -i $LANDEV -j ACCEPT
		iptables -A INPUT -j LOG --log-prefix "iptables drop INPUT: "

		iptables -P OUTPUT DROP
		iptables -A OUTPUT -o lo -j ACCEPT
		iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A OUTPUT -p icmp --icmp-type echo-request -j ACCEPT
		iptables -A OUTPUT -m multiport -p tcp --dport 22,53,2222 -o $DMZDEV -d $DMZ -j ACCEPT
		iptables -A OUTPUT -m multiport -p udp --dport 53 -o $DMZDEV -d $DMZ -j ACCEPT
		iptables -A OUTPUT -j LOG --log-prefix "iptables drop OUTPUT: "

		iptables -P FORWARD DROP
		iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $WANDEV -o $DMZDEV -d $DNSSERVER -j ACCEPT
		iptables -A FORWARD -m multiport -p tcp --dport 80,443 -i $LANDEV -j ACCEPT
		iptables -A FORWARD -m multiport -p tcp --dport 53,80,443 -i $DMZDEV -o $WANDEV -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $LANDEV -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $DMZDEV -o $WANDEV -j ACCEPT
		iptables -A FORWARD -p icmp --icmp-type echo-request -j ACCEPT
		iptables -A FORWARD -j LOG --log-prefix "iptables drop FORWARD: "

		iptables -t nat -A PREROUTING -p udp --dport 53 -i $WANDEV -j DNAT --to $DNSSERVER

		iptables -t nat -A POSTROUTING -s $LAN -o $WANDEV -j SNAT --to-source $WANIP
		iptables -t nat -A POSTROUTING -s $DMZ -o $WANDEV -j SNAT --to-source $WANIP
		;;
	stop)
		echo "stoppe Firewall"
		iptables -F
		iptables -F -t nat
		iptables -P INPUT ACCEPT
		iptables -P OUTPUT ACCEPT
		iptables -P FORWARD ACCEPT

		# Internetzugriff für alle mit dynamischer IP
		iptables -t nat -A POSTROUTING -o $WANDEV -j MASQUERADE
		;;
	*)
		echo "usage: $0 start|stop"
		;;
esac

Webserver in der DMZ

statische IP: 10.0.1xx.3/24
Hostname: www
SSH Zugang wie beim DNS Server
Testwebserver installieren
apt install apache2
Portforwarding einrichten
vim /usr/local/sbin/firewall

WEBSERVER="10.0.1xx.3"
...
iptables -A FORWARD -m multiport -p tcp --dport 80,443 -i $WANDEV -o DMZDEV -d $WEBSERVER -j ACCEPT
...
iptables -t nat -A PREROUTING -m multiport -p tcp --dport 80,443 -i $WANDEV -j DNAT --to $WEBSERVER
...

vim /var/cache/bind/intern/lab1xx.sec

$TTL 300
@		IN	SOA	dns.lab1xx.sec. mail.lab1xx.sec. (2023091302 14400 3600 3600000 86400) 
		IN	NS	dns
firewall	IN	A	192.168.11.1xx
dns		IN	A	10.0.1xx.2
web		IN	A	10.0.1xx.3
sftp		IN	A	10.0.1xx.4
lan		IN	A	172.16.1xx.2
www		IN	A	192.168.11.1xx

Verschlüsseln des Datenverkehrs zwischen den Laboren mit VPNs

Ziel ist es die LANs zwischen Laboren durch eine VPN zu verbinden, damit die Administration auch über einen entfernten Standort stattfinden kann.

Als Vorbereitung benötigen wir einen SFTP-Server, um den Pre-Shared-Key und die Zertifikate auszutauschen:
- Netzwerk: DMZ
- IP: 10.0.1xx.4/24
- Hostname: sftp
- Firewall sollte von TCP Port 22 auf den SSH Port des SFTP-Servers zulassen
- sftp.labxx.sec sollte auflösbar sein (auf intern und extern achten)
- SSH-Schlüssel hinterlegen
Außerdem sollte die Firewall Zugriff auf externe SFTP Server erlauben
vim /usr/local/sbin/firewall

#!/bin/bash

LANDEV="enp0s8"
DMZDEV="enp0s9"
WANDEV="enp0s3"
LAN="172.16.1xx.0/24"
DMZ="10.0.1xx.0/24"
WANIP="192.168.3.1xx"
DNSSERVER="10.0.1xx.2"
WEBSERVER="10.0.1xx.3"
SFTPSERVER="10.0.1xx.4"

case $1 in
	start)
		echo "starte Firewall"
		iptables -F
		iptables -F -t nat

		iptables -P INPUT DROP
		iptables -A INPUT -i lo -j ACCEPT
		iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A INPUT -p tcp --dport 2222 -i $LANDEV -s $LAN -j ACCEPT
		iptables -A INPUT -p icmp --icmp-type echo-request -i $LANDEV -j ACCEPT
		iptables -A INPUT -j LOG --log-prefix "iptables drop INPUT: "

		iptables -P OUTPUT DROP
		iptables -A OUTPUT -o lo -j ACCEPT
		iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A OUTPUT -p icmp --icmp-type echo-request -j ACCEPT
		iptables -A OUTPUT -m multiport -p tcp --dport 22,53,2222 -o $DMZDEV -d $DMZ -j ACCEPT
		iptables -A OUTPUT -m multiport -p udp --dport 53 -o $DMZDEV -d $DMZ -j ACCEPT
		iptables -A OUTPUT -j LOG --log-prefix "iptables drop OUTPUT: "

		iptables -P FORWARD DROP
		iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $WANDEV -o $DMZDEV -d $DNSSERVER -j ACCEPT
		iptables -A FORWARD -m multiport -p tcp --dport 80,443 -i $WANDEV -o $DMZDEV -d $WEBSERVER -j ACCEPT
		iptables -A FORWARD -p tcp --dport 2222 -i $WANDEV -o $DMZDEV -d $SFTPSERVER -j ACCEPT
		iptables -A FORWARD -m multiport -p tcp --dport 22,80,443 -i $LANDEV -j ACCEPT
		iptables -A FORWARD -m multiport -p tcp --dport 53,80,443 -i $DMZDEV -o $WANDEV -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $LANDEV -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $DMZDEV -o $WANDEV -j ACCEPT
		iptables -A FORWARD -p icmp --icmp-type echo-request -j ACCEPT
		iptables -A FORWARD -j LOG --log-prefix "iptables drop FORWARD: "

		iptables -t nat -A PREROUTING -p udp --dport 53 -i $WANDEV -j DNAT --to $DNSSERVER
		iptables -t nat -A PREROUTING -m multiport -p tcp --dport 80,443 -i $WANDEV -j DNAT --to $WEBSERVER
		iptables -t nat -A PREROUTING -p tcp --dport 22 -i $WANDEV -j DNAT --to $SFTPSERVER:2222

		iptables -t nat -A POSTROUTING -s $LAN -o $WANDEV -j SNAT --to-source $WANIP
		iptables -t nat -A POSTROUTING -s $DMZ -o $WANDEV -j SNAT --to-source $WANIP
		;;
	stop)
		echo "stoppe Firewall"
		iptables -F
		iptables -F -t nat
		iptables -P INPUT ACCEPT
		iptables -P OUTPUT ACCEPT
		iptables -P FORWARD ACCEPT

		# Internetzugriff für alle mit dynamischer IP
		iptables -t nat -A POSTROUTING -o $WANDEV -j MASQUERADE
		;;
	*)
		echo "usage: $0 start|stop"
		;;
esac

SSH Daemon lauscht auf TCP Port 2222, aber sollte Passwortauthentifikation für die Gruppe sftponly zulassen
vim /etc/ssh/sshd_config

...
Subsystem sftp /usr/lib/openssh/sftp-server

UsePAM yes
Match Group sftponly
        PasswordAuthentication yes
        ChrootDirectory /srv/sftp/%u
        ForceCommand internal-sftp
        AllowTcpForwarding no

Für die Einrichtung des SFTP-Servers sollten folgende Ordner und Benutzer angelegt werden
mkdir -p /srv/sftp
groupadd sftponly
useradd -G sftponly -d /srv/sftp/gast -s /bin/false gast
mkdir -p /srv/sftp/gast/ablage
chown gast /srv/sftp/gast/ablage
passwd gast
systemctl restart sshd
Der Partner mit dem man die VPN aufbauen will, sollte das Passwort für den SFTP Account erfahren
Nun kann man die IPsec Implementation Strongswan auf der Firewall installieren
apt install strongswan
Die Verbindungen werden unter der Datei /etc/ipsec.conf konfiguriert

IPsec Site-to-Site aufbauen mit PSK

[Bearbeiten]

Diese Einstellung kann auf beiden Seite gleich angewendet werden (bis auf die IPs)
apt install strongswan
xx eigene Seite, gegenüberliegende Seite yy
vim /etc/ipsec.conf

conn site2site-psk
     authby=secret
     keyexchange=ikev2
     left=192.168.3.1yy
     leftid=192.168.3.1yy
     leftsubnet=172.16.1yy.0/24
     mobike=no
     right=192.168.3.1xx
     rightid=192.168.3.1xx
     rightsubnet=172.16.1xx.0/24
     ike=aes256-sha256-modp4096!
     esp=aes256-sha256-modp4096!
     auto=start

Nun sollte über den SFTP-Server der PSK ausgetauscht werden
Dazu muss TCP Port 22 nach außen für die Firewall freigeschaltet sein (falls es noch nicht so da steht)
vim /usr/local/sbin/firewall

...
iptables -A OUTPUT -p tcp --dport 22 -j ACCEPT
...

Partner 1

Eine Seite generiert einen Schlüssel, z.B. head /dev/random | tr -dc A-Za-z0-9 | head -c 20 ; echo
Dieser Schlüssel muss auf dem SFTP-Server abgespeichert werden.

Partner 2

Nun kann sich die Gegenseite den Schlüssel holen (Vom LAN Host aus sollte Port 22 in der Forward-Kette freigeschaltet werden)
sftp gast@sftp.lab1yy.sec
get ipsec.secret
Danach sollte der Schlüssel wieder vom SFTP Server gelöscht werden

Beide

Wenn beide Seiten den Schlüssel haben, kann man nun diese in die Datei ipsec.secrets eintragen
vim /etc/ipsec.secrets

192.168.3.1xx 192.168.3.1yy : PSK "hierdertotalgeheimeschlüssel"

Auf der Firewall noch in der INPUT-Kette UDP Port 500 und 4500 freischalten
vim /usr/local/sbin

...
iptables -A INPUT -m multiport -p udp --dport 500,4500 -i $WANDEV -j ACCEPT
...
iptables -A OUTPUT -m multiport -p udp --dport 500,4500 -o $WANDEV -j ACCEPT
...

Nun sollte man die IPsec Verbindung aufbauen können
ipsec up site2site-psk
Verbindung herunterfahren
ipsec down site2site-psk
Verbindung status
ipsec status site2site-psk
Den Status der Verbindung kann man mit ipsec statusall checken
Falls die Verbindung steht sollte ein Ping in das gegenüberliegende Netz auch funktionieren
ping -I 172.16.1xx.1 172.16.1yy.1

IPsec Site-to-Site aufbauen mit Zertifikat

Partner 1 wartet auf eine eingehende Verbindung mit passenden Zertifikat, wobei die IP egal sein darf
Commonname/FQDN im Zertifikat sollte fw1xx bzw. fw1yy sein
Austausch der Zertifikate und der Anträge über den SFTP Server
PSK-VPN-Verbindung abbauen
ipsec down site2site-psk

Partner 1

Zertifizierungsstelle erstellen
mkdir ~/ca
cd ~/ca
openssl genrsa -aes256 -out ca.key 4096
openssl req -new -key ca.key -x509 -days 3650 -out ca.crt

...
Common Name (e.g. server FQDN or YOUR name) []:vpn-ca
...

IPsec-Zertifikat erstellen und signieren
openssl genrsa -out fw1xx.key 4096
Einen Certificate Signing Request erstellen
openssl req -new -key fw1xx.key -out fw1xx.csr

...
Common Name (e.g. server FQDN or YOUR name) []:fw1xx 
...

openssl x509 -req -days 730 -in fw1xx.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out fw1xx.crt
Zertifikat der Zertifizierungsstelle Partner 2 zukommen lassen (ca.crt)

Partner 2

Erstellt Zertifizierungsantrag...
mkdir ~/cert
cd ~/cert
openssl genrsa -out fw1yy.key 4096
openssl req -new -key fw1yy.key -out fw1yy.csr

...
Common Name (e.g. server FQDN or YOUR name) []:fw1yy 
...

... und lässt es Partner 1 zukommen (fw1yy.csr)
Konfigurieren der Verbindung
vim /etc/ipsec.conf

conn site2site-cert
     authby=rsasig
     keyexchange=ikev2
     left=192.168.3.1yy
     leftcert="fw1yy.crt"
     leftsubnet=172.16.1yy.0/24
     right=192.168.3.1xx
     rightid="CN=fw1xx"
     rightsubnet=172.16.1xx.0/24
     ike=aes256-sha256-modp4096!
     esp=aes256-sha256-modp4096!
     auto=start

Partner 1

Signiert den Antrag
openssl x509 -req -days 730 -in fw1yy.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out fw1yy.crt
Schickt diesen zurück bzw. hinterlegt ihn auf dem SFTP Server (fw1yy.crt) zusammen mit dem Zertifikat der Zertifizierungsstelle (ca.crt)
Konfigurieren der Verbindung
vim /etc/ipsec.conf

conn site2site-cert
     authby=rsasig
     keyexchange=ikev2
     left=192.168.3.1xx
     leftcert="fw1xx.crt"
     leftsubnet=172.16.1xx.0/24
     right=0.0.0.0 # Egal welche IP,...
     rightid="CN=fw1yy" # ...aber der Commonname muss stimmen
     rightsubnet=172.16.1yy.0/24
     ike=aes256-sha256-modp4096!
     esp=aes256-sha256-modp4096!
     auto=add

Beide

Damit Strongswan die Zertifikate findet, müssen diese an genau diesen Stellen liegen...
find /etc/ipsec.d/ -type f

/etc/ipsec.d/private/fw1xx.key # bzw. f1yy.key
/etc/ipsec.d/certs/fw1xx.crt # bzw. f1yy.crt
/etc/ipsec.d/cacerts/ca.crt

...und in der ipsec.secrets Datei zur Verbindung zugewiesen werden
vim /etc/ipsec.secrets

192.168.3.1xx : RSA fw1xx.key

Diese müssen von Strongswan neu eingelesen werden
ipsec reload
ipsec rereadall
Ob die Zertifikate erfolgreich geladen wurden lässt sich folgendermaßen überprüfen
ipsec listcerts
Ansonsten muss Strongswan neugestartet/geladen werden, falls der letzte Befehl nichts ausgibt
systemctl restart strongswan-starter
ipsec restart

Partner 2

Nur von dieser Firewall aus kann die Verbindung gestartet werden, da die andere Seite die IP nicht kennt
ipsec up site2site-cert

Pakete durch den VPN Tunnel schicken

Selbst wenn die VPN Tunnel stehen, heißt es noch nicht, dass unsere Datenpakete auch verschlüsselt verschickt werden
Am einfachsten kann man das überprüfen, indem man versucht sowohl ICMP- als auch ESP-Pakete mitzuschneiden
tcpdump -i any icmp or esp
Falls nur ICMP-Pakete auftauchen heißt es, dass noch nichts verschlüsselt wird
Die Firewall muss nun auf vier Dinge angepasst werden:

Pakete, die für das andere LAN bestimmt sind müssen durch den VPN-Tunnel gezwungen werden
Dadurch werden die Pakete beim Forwarden als ipsec-Pakete markiert, was wir durch ein Modul freischalten können
Aus-/Eingehende ESP-Pakete müssen erlaubt werden
Pakete aus dem anderen LAN müssen vor den Regeln der PREROUTING-Kette bewahrt werden, falls es sich um das WAN-Interface handelt

vim /usr/local/sbin/firewall

#!/bin/bash

LANDEV="enp0s8"
DMZDEV="enp0s9"
WANDEV="enp0s3"
LAN="172.16.1xx.0/24"
DMZ="10.0.1xx.0/24"
WANIP="192.168.3.1xx"
DNSSERVER="10.0.1xx.2"
WEBSERVER="10.0.1xx.3"
SFTPSERVER="10.0.1xx.4"
RIGHTNET=172.16.1yy.0/24

case $1 in
	start)
		echo "starte Firewall"
		iptables -F
		iptables -F -t nat

		iptables -P INPUT DROP
		iptables -A INPUT -i lo -j ACCEPT
		iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A INPUT -p tcp --dport 2222 -i $LANDEV -s $LAN -j ACCEPT
		iptables -A INPUT -i $WANDEV -p esp -j ACCEPT
		iptables -A INPUT -m multiport -p udp --dport 500,4500 -i $WANDEV -j ACCEPT
		iptables -A INPUT -p icmp --icmp-type echo-request -i $LANDEV -j ACCEPT
		iptables -A INPUT -j LOG --log-prefix "iptables drop INPUT: "

		iptables -P OUTPUT DROP
		iptables -A OUTPUT -o lo -j ACCEPT
		iptables -A OUTPUT -o $WANDEV -p esp -j ACCEPT
		iptables -A OUTPUT -m multiport -p udp --dport 500,4500 -o $WANDEV -j ACCEPT
		iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A OUTPUT -p icmp --icmp-type echo-request -j ACCEPT
		iptables -A OUTPUT -m multiport -p tcp --dport 22,53,2222 -o $DMZDEV -d $DMZ -j ACCEPT
		iptables -A OUTPUT -m multiport -p udp --dport 53 -o $DMZDEV -d $DMZ -j ACCEPT
		iptables -A OUTPUT -j LOG --log-prefix "iptables drop OUTPUT: "
 
		iptables -P FORWARD DROP
		iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $WANDEV -o $DMZDEV -d $DNSSERVER -j ACCEPT
		iptables -A FORWARD -m multiport -p tcp --dport 80,443 -i $WANDEV -o $DMZDEV -d $WEBSERVER -j ACCEPT
		iptables -A FORWARD -p tcp --dport 2222 -i $WANDEV -o $DMZDEV -d $SFTPSERVER -j ACCEPT
		iptables -A FORWARD -m multiport -p tcp --dport 80,443 -i $LANDEV -j ACCEPT
		iptables -A FORWARD -m multiport -p tcp --dport 53,80,443 -i $DMZDEV -o $WANDEV -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $LANDEV -j ACCEPT
		iptables -A FORWARD -p udp --dport 53 -i $DMZDEV -o $WANDEV -j ACCEPT
		iptables -A FORWARD -p icmp --icmp-type echo-request -j ACCEPT
		iptables -A FORWARD -i $WANDEV -o $LANDEV -m policy --dir in --pol ipsec -j ACCEPT
		iptables -A FORWARD -i $LANDEV -o $WANDEV -m policy --dir out --pol ipsec -j ACCEPT
		iptables -A FORWARD -j LOG --log-prefix "iptables drop FORWARD: "

 		iptables -t nat -A PREROUTING -i $WANDEV -s $RIGHTNET -j RETURN
		iptables -t nat -A PREROUTING -p udp --dport 53 -i $WANDEV -j DNAT --to $DNSSERVER
		iptables -t nat -A PREROUTING -m multiport -p tcp --dport 80,443 -i $WANDEV -j DNAT --to $WEBSERVER
		iptables -t nat -A PREROUTING -p tcp --dport 22 -i $WANDEV -j DNAT --to $SFTPSERVER:2222

		iptables -t nat -A POSTROUTING -s $LAN -o $WANDEV -d $RIGHTNET -j RETURN
		iptables -t nat -A POSTROUTING -s $LAN -o $WANDEV -j SNAT --to-source $WANIP
		iptables -t nat -A POSTROUTING -s $DMZ -o $WANDEV -j SNAT --to-source $WANIP
		;;
	stop)
		echo "stoppe Firewall"
		iptables -F
		iptables -F -t nat
		iptables -P INPUT ACCEPT
		iptables -P OUTPUT ACCEPT
		iptables -P FORWARD ACCEPT

		# Internetzugriff für alle mit dynamischer IP
		iptables -t nat -A POSTROUTING -o $WANDEV -j MASQUERADE
		;;
	*)
		echo "usage: $0 start|stop"
		;;
esac

OpenVPN

Hier kann man alleine weitermachen
Diffie-Hellman Parameter erzeugen (kann eine Weile dauern)
openssl dhparam -out /etc/openvpn/ssl/dh2048.pem 2048
vim /etc/openvpn/user-auth-server.conf

dev tun
mode server
tls-server
topology subnet
server 172.24.24.0 255.255.255.0
route-gateway 172.24.24.1
push 'route 172.16.1xx.0 255.255.255.0'
cipher AES-256-CBC
link-mtu 1543
keepalive 10 30
client-to-client
dh ssl/dh2048.pem
ca ssl/ca.crt
cert ssl/fw1xx.crt
key ssl/fw1xx.key
verify-client-cert none
plugin /usr/lib/openvpn/openvpn-plugin-auth-pam.so /etc/pam.d/login

Diese Konfiguration starten
systemctl daemon-reload
systemctl start openvpn@user-auth-server
Nun geht es auf dem LAN Host weiter
Das Zertifikat der Zertifizierungsstelle holen und in die OpenVPN Konfigurationsdatei einbinden
scp root@fw:/etc/openvpn/ssl/ca.crt .
Distributionsabhängig OpenVPN installieren
apt install openvpn
pacman -S openvpn
Client-Konfiguration erstellen mit dem Inhalt der ca.crt
vim lab1xx.ovpn

dev tun0
remote 192.168.3.1xx
tls-client
cipher AES-256-CBC
pull
auth-user-pass

<ca>
-----BEGIN CERTIFICATE-----
MIIFAzCCAuugAwIBAgIUL5Pyu5Rlwi/noznd1CWK3r4IZiEwDQYJKoZIhvcNAQEL
BQAwETEPMA0GA1UEAwwGdnBuLWNhMB4XDTIzMDgwNjA3NDY1N1oXDTI0MDgwNTA3
NDY1N1owETEPMA0GA1UEAwwGdnBuLWNhMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A
MIICCgKCAgEAuYYi369+gKR0RC4vdRvpB0bL6EuUEiwDaPD7XDE5i21gyC/Z5wOr
bv8UTZ1JO4UoTabUZaCDjNOjG4dJA/dr4LKwmnugS2ODO+Bk9fmPpeRVVVFi5kZR
zX6iqNkXXydmIYwxJcTzHq+Dro0jSMUsOChhGhuI+DqU2jbiLm4LsQ//EzMwt54l
igLNynA8k6cg20sDekaSiZm3STQh4SOwBGVWzH0MX0l7PvOpFs22rdnWGGCkdQlo
6yG+oLGwd8G8zJFBNfwQTWKYRkAlJi3gGC+tXMsbQflyImqATVsMOAH0dGCetlfV
izrzApTz0ntPxdp4cF2dE6VWvip+GBMZuned4fKXNzkl+Vf4IhmUxxPrBxUViSgM
UCftojAecB9+6fgETJ2NcZejqSv7QHZN86MBb2sB2IftEqGk0VCS+MeXZglf8AwY
SK5iV9oc97GHbrPdXDlJOwI5MrqCNv+T5BzwuVJ4sRXORSZsDVrz7MpAPaZj86lr
V3KB3RQWDQrxMJyG4K7gBMbJBW7YUIdmviVUFB9k6zv53pvfedM2vHbrCbFATtrj
dXNTy4dl3dLTV9NGjYXPa66JpsFIR4UgWGugSoEsGn7m7zqZ43IGrRPOn7spEqCR
r1gGGM1mVeVKB0cdG++jK/3FNjrWuVPT2K7IyzxMep4A1fKhl56mJR8CAwEAAaNT
MFEwHQYDVR0OBBYEFOrV2doki3JZ0qs9IvnJ2PK1t3azMB8GA1UdIwQYMBaAFOrV
2doki3JZ0qs9IvnJ2PK1t3azMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
BQADggIBALhBLzogYcNrMghWu4JBD9+gY8+7BwvZW8oFa4yO2Cb+VQ56oyOeq2IW
QoNQgQpTKFPPMw/gfe8bTfbFP1qG/nfxoHBrzn5Gt6hkTQ3dhvNkkOiQDYlXhJ0v
pNs+UVxkDhQxPBwvlE5BQIvElGKcEfrgXqQE6zdWWP5b6yrt8eTI+TBP32+hS3gc
I6pvKEv2mxd/SchXlbNEKqUYdYldxc4GXwuYKfgjzo+aAbaw2FCbiVtwg8f7a3ky
GtYUP41eEl24FyRWI4L/wLPha8k7YjZqiTB8NKj5L7sB+mKbMXsEwqlKh8BmjPXN
WAGVpfcetV0UkJS/diKZyqTa1MFb4TIexpNa9GLxEGGg8zsgVypL2TG5sCiecoSF
gGbm7yE9Yb4IF0v4X57gbULAZFMzaUkk65Y2f2VJ5RoJCBl51SWOWm5gMXz5vmwk
GihwB+oLvcjoZIBc3MrB9ZHdZ60qCzOtTGiSlhqfJETrzaRgAx5Z4PWY9F9iwucC
OW9eOMXpOPqW80CO/Y0srX9C9LpmM/s9SXzgey+MV+iH5VPE3eMVDj7axQsPbgqb
lXoRa2ENyOltSPzejlh33DHoYreov464JtrMMjQ6I2YlcXlUJycL2gPysA0Ad/zd
I2p2luSylfNI7DdfmuZrhhdlPg1kMS2QzyQr2quf9YZSJwSgdbhr
-----END CERTIFICATE-----
</ca>

Nun die Maschine ausschalten, klonen und "außerhalb" des Labors hängen (NAT Adapter bzw. Netzwerkbrücke)
openvpn --config lab1xx.ovpn

HIDS

[Bearbeiten]

AIDE

statische AIDE

apt install aide
Aide Config
Aide Test
Änderungen bestätigen und Datenbank updaten
aide --config=/etc/aide/aide.conf --update
cp -v /var/lib/aide/aide.db{.new,}

dynamische AIDE

Es wird davon abgeraten dynamisches AIDE zu verwenden
apt install aide-dynamic
Eine bösartig verlinkte Funktionsbibliothek könnte zur Fehlfunktion von AIDE führen
Unterschiede statisch vs. dynamisch gelinked

Tripwire

apt update && apt install tripwire
Man kann alle Prompts bei der Installation mit Ja bestätigen
Die Passphrasen für Local-/Site-Key sollte man sich merken
Diese werden zum Signieren von Änderungen benutzt
Auch hier die Default Policy-Datei als Backup/Referenz nutzen
cd /etc/tripwire
mv /etc/tripwire/twpol.txt{,.orig}
vim /etc/tripwire/twpol.txt

/etc -> $(ReadOnly);
!/etc/tripwire;

twadmin --create-polfile /etc/tripwire/twpol.txt
Mehr Syntax kann man nachlesen unter: man twpolicy (relativ ähnlich zu AIDE)
Tripwire verwaltet eine Datenbank um auf Regelverstöße zu prüfen.
tripwire --init
tripwire --check -r report.twr
touch /etc/ssh/newfile
tripwire --check -r report.twr
Für ein Datenbankupdate muss der dazugehörige Bericht mit angegeben werden, falls nicht die Default Datei verwendet wurde
tripwire --update -r report.twr
tripwire --check -r report.twr
Den Schweregrad des Regelverstoßes kann man auch anpassen

/etc -> $(ReadOnly) (severity=35);
/root -> $(ReadOnly) (severity=10);
!/etc/tripwire;

Fail2ban für SSH/SFTP einrichten

apt install iptables fail2ban
Plan ist es den DNS Server als Angreifer auf den SFTP Server zu starten
Fail2ban ssh

Proxies

SOCKS Proxy

SOCKS Proxies verbinden Client und Server protokollunabhängig über einen Proxy
Eine verschlüsselte SOCKS Verbindung kann man am einfachsten mit SSH erreichen
ssh -fnN -D 8080 kit@sftp
curl www.lab1xx.sec
curl --socks5 localhost:8080 www.lab1xx.sec
Unterschiedliche IPs sollten unter /var/log/apache2/access.log zu sehen sein

Squid als Standard Proxy

Ein einfacher Proxy soll eingerichtet werden
Über die Source-IP wird kontrolliert, ob ein Client den Proxy benutzen darf
Weitere ACLs können den Zugriff auf bestimmte Webseiten blockieren

Transparenter Proxy

Clients im LAN sollen nicht die Möglichkeit haben den Proxy zu umgehen, indem sie den Eintrag aus dem Browser entfernen
Über Firewall-Regeln können die Webanfragen auf den Proxy geleitet werden

Virenscanning mit ClamAV in Squid

Durch Installieren von Stammzertifikaten auf den Browsern der Clients, soll Squid die Möglichkeit haben die Inhalte der Webseiten zu scannen
Der Proxy kann so dann verhindern, dass Clients sich Viren herunterladen

Suricata

[Bearbeiten]

ein IDS/IPS matcht im Gegensatz zur Firewall auch auf höheren Schichten.
So können z.B. bestimmte DNS Abfragen oder HTTP Anfragen gemeldet oder blockiert werden
Ein weiterer Anwendungsfall wäre die Version von Diensten zu überprüfen und jene mit bekannten Schwachstellen ablehnen
Als Angriffsziel können wir OWASP Juice Shop auf dem Webserver installieren

Suricata Installation

Suricata IDS

Suricata IPS

Mandatory Access Control

Apparmor

SELinux

Als Angriffsziel modifizieren wir den Apache2 Server: Command Injection Proof of Concept
Ein Benutzer versucht ein Programm aufzurufen.
Dem Benutzer ist ein Benutzer Typ zugeordnet.
Dem Pragamm ist ein Progamm Typ zugeordnet.
SELinux checkt nun ob der Benutzer Typ das Programm anhand des Programm Typ aufrufen darf.
Dann wird gecheckt ob der Benutzer Typ zu dem Prozess Typ transitieren darf.
Wenn dies erlaubt ist transitiert der Benutzer Typ zum Prozess Typ.
Der Prozess läuft dann mit den entsprechenden Rechten unter seinem Prozess Typ.
Diese Command Injection Schwachstelle lässt sich mit SELinux beheben
Damit der Ping aber weiterhin funktioniert, muss noch ein Richtlinienmodul geladen werden, der speziell für Apache2 das Pingen erlaubt
setenforce 0
Normal auf der Weboberfläche pingen (Keine Reverse Shell aufbauen!)
Nun kann man die Verstöße in ein ladbares Modul umwandeln, welches speziell nur die Rechte vergibt, um Ping zuzulassen
ausearch -m AVC -ts recent | audit2allow -M apache2-ping
semodule -i apache2-ping.pp
setenforce 1
Nun sollte das Öffnen eines Portes durch Command Injection durch SELinux verhindert werden
Die Verstöße kann man sich nochmal mit ausearch anzeigen lassen
!!Achtung!! Andere Kommandos könnten jedoch immernoch ausgeführt werden, z.B. 1.1.1.1 ; ls zeigt uns den Inhalt des Ordners /var/www/html

Greenbone Security/Vulnerability Manager (Hacking & Security Seite 161)

Kali Vorlage auf den realen Host ziehen
Neue Maschine hinzufügen mit Netzwerkbrücke
Benutzer/Passwort: kali/kali
sudo -i
apt update
apt install gvm
GVM initialisieren und das Passwort merken, aufschreiben oder in eine Datei speichern
gvm-setup
gvm-check-setup
Die Initialisierung der Datenbank kann einige Stunden dauern
Die Datenbank kann auch manuell geupdatet werden
greenbone-feed-sync --type scan-config
Falls das immernoch nicht funktioniert
Die User ID des Admins holen...
runuser -u _gvm -- gvmd --get-users --verbose
...und Konfiguration des Benutzers ändern
runuser -u _gvm -- gvmd --modify-setting 78eceaec-3385-11ea-b237-28d24461215b --value <uuid_of_user>

Portscanning

Die Effektivität der Firewall soll mit nmap getestet werden
Für einen Vergleich scannen wir einmal mit Default-Policy accept und einmal mit drop

IP bei zuvielen Anfragen sperren

Original: https://wiki.archlinux.org/title/Nftables#Dynamic_blackhole
vim /etc/nftables.conf

table inet filter {
    set blackhole {
        type ipv4_addr;
        flags dynamic, timeout;
        size 65536;
    }

    chain input {
        ...
        ct state new tcp dport 80 \
                meter flood size 128000 { ip saddr timeout 10s limit rate over 10/minute } \
                add @blackhole { ip saddr timeout 1m }

        ip saddr @blackhole counter drop
    }
    ...
}

Linux - Security und Firewall Plan - Linkai

Ziel

physischer Netzwerkplan

logischer Netzwerkplan

VirtualBox Vorlage

Aufbau des Labors

Hostzugriff absichern

Remotezugriff mit SSH

Router Firewall

Masquerade

Ports blockieren

DHCP

Switch

Bridge Firewall

VLANs konfigurieren

DNS für das Labor einrichten

Vorbereitungen

lab1xx.sec

Zonenkonfiguration

Portforwarding mit iptables

Webserver in der DMZ

Verschlüsseln des Datenverkehrs zwischen den Laboren mit VPNs

IPsec Site-to-Site aufbauen mit PSK

Partner 1

Partner 2

Beide

IPsec Site-to-Site aufbauen mit Zertifikat

Partner 1

Partner 2

Partner 1

Beide

Partner 2

Pakete durch den VPN Tunnel schicken

HIDS

statische AIDE

dynamische AIDE

Fail2ban für SSH/SFTP einrichten

SOCKS Proxy

Greenbone Security/Vulnerability Manager (Hacking & Security Seite 161)

Portscanning

IP bei zuvielen Anfragen sperren

Navigationsmenü

Suche