Unix-/Linux Netz: Unterschied zwischen den Versionen

Aus Xinux Wiki
Zur Navigation springen Zur Suche springen
Zeile 513: Zeile 513:
 
  '''log prefix "--nftables-drop-output--"'''
 
  '''log prefix "--nftables-drop-output--"'''
 
  }
 
  }
−
   
+
  }
 
  table inet nat {
 
  table inet nat {
 
  chain prerouting {
 
  chain prerouting {

Version vom 4. Dezember 2024, 08:37 Uhr

Netzwerk der Schulung

  • 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
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

  • 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.0.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 Arch 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 Arch;
    fixed-address 192.168.0.2;
    option routers 192.168.0.1;
}
  • systemctl restart isc-dhcp-server

DNS Server

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 Arch 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: 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
  • Arch 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 "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.nux. technik.xinux.de. (2023050901 14400 3600 3600000 86400)
        IN NS   dns.lab100.nux.
1       IN PTR  fw.lab100.nux.
2       IN PTR  dns.lab100.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

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 $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

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

  • 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.RNr.1.1xx
define webserver = 10.0.1xx.2

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

LDAP Server einrichten

  • 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:
  1. Hostname auf ldap setzen
  2. statische IP vergeben
  3. SSH Schlüssel hinterlegen
  4. Eintrag im DNS Server vornehmen
  • eventuell muss auf der Firewall Port 80 und 443 für die DMZ freigeschaltet werden, damit die Pakete heruntergeladen werden können
  • LDAP
  • Openldap Basic Config common

HAProxy für zentrale SSL Terminierung

  • Im Moment ist nur SSH verschlüsselt
  • Pakete von HTTP Verbindungen zwischen den LAN und DMZ werden im Klartext verschickt
  • Problem: Jemand der den Verkehr mitscheidet, kann alles lesen
  • Lösung: Upgrade auf HTTPS mit Zertifikaten
  • SFTP-Server für den sicheren Transfer der Zertifikatsanträge
  • eine neue VM vom Template klonen und Grundeinstellungen vornehmen:
  1. Hostname auf haproxy setzen
  2. statische IP vergeben 10.0.1xx.2
  3. SSH Schlüssel hinterlegen
  4. Eintrag im DNS Server vornehmen
  5. signiertes Wildcard-Zertifikat rüberkopieren
  6. privaten Zertifikatsschlüssel rüberkopieren
  • Signiertes Zertifikat vom SFTP Server holen
  • sftp -P 9922 cert_req@172.RNr.1.100
  • get cert/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
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
  • systemctl restart haproxy

Squid Proxy auf der Firewall

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

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

Abgerufen von „http://wiki.ixheim.de/index.php?title=Unix-/Linux_Netz&oldid=58644“