Unix-/Linux Netz: Unterschied zwischen den Versionen

Aus Xinux Wiki
Zur Navigation springen Zur Suche springen
(Die Seite wurde neu angelegt: „{{#drawio:unix-linux}}“)
 
 
(222 dazwischenliegende Versionen von 3 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
−
{{#drawio:unix-linux}}
+
=Netzwerk der Schulung=
 +
[[Anpassung der Virtuellen Maschine UNIX/LINUX Netz]]
 +
* Die WAN-IP wird die 172.RNr.0.(100 + eigene Nr.)
 +
* Die '''D'''e'''m'''ilitarisierte '''Z'''one (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
 +
 
 +
{{#drawio:ul2}}
 +
 
 +
;''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 =
 +
 
 +
{{#drawio:ul-tag-0}}
 +
 
 +
* Wir klonen den Rechner "Server Vorlage" und nennen ihn "Firewall"
 +
* Dieser braucht 3 Netzwerkadapter:
 +
# Netzwerkbrücke
 +
# Internes Netzwerk "LAN"
 +
# 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.1''xx''/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.1''xx''.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.1''xx''/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.1''xx''.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 fw''xx'' '''
 +
* '''vim /etc/hosts'''
 +
 
 +
127.0.0.1 localhost
 +
127.0.1.1 '''fw''xx'' '''
 +
...
 +
 
 +
* 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
 +
 
 +
* '''S'''ource '''N'''etwork '''A'''ddress '''T'''ranslation 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 fw''xx''
 +
Hostname 192.168.0.1
 +
User root
 +
Port 2222
 +
 
 +
* Jetzt kann man den Befehl folgendermaßen verkürzen:
 +
* '''ssh fw''xx'' '''
 +
 
 +
= 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.1''xx''.0 netmask 255.255.255.0 {'''
 +
    '''range 10.0.1''xx''.50 10.0.1''xx''.100;'''
 +
    '''option routers 10.0.1''xx''.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 =
 +
 
 +
{{#drawio:ul-tag-1}}
 +
 
 +
== 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.lab1''xx''.nux'''
 +
* '''dig +short fw.lab1''xx''.nux'''
 +
 
 +
== '''D'''estination 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.1''xx'' '''
 +
'''define dnsserver = 10.0.1''xx''.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.lab''1xx''.nux'''
 +
* '''ping fw.lab''1xx''.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.1''xx''
 +
dns.lab102      A      172.RNr.0.1''xy''
 +
 
 +
= 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 Netze absichern|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
 +
 
 +
{{#drawio:nft-inet1}}
 +
 
 +
== 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==
 +
<pre>
 +
#!/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
 +
}
 +
}
 +
 
 +
</pre>
 +
 
 +
== '''C'''onnection '''T'''racking '''T'''abelle ==
 +
 
 +
* 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 =
 +
 
 +
{{#drawio:ul-tag-2}}
 +
 
 +
[[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]]
 +
<pre>
 +
#!/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
 +
}
 +
}
 +
</pre>
 +
 
 +
==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===
 +
<pre>
 +
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;
 +
}
 +
 
 +
</pre>
 +
 
 +
== '''D'''estination 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
 +
 
 +
<pre>
 +
#!/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
 +
        }
 +
}
 +
 
 +
</pre>
 +
* '''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 =
 +
 
 +
{{#drawio:ul-tag-3}}
 +
 
 +
* 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 =
 +
 
 +
{{#drawio:ul-tag-4}}
 +
 
 +
* eine neue VM vom Template klonen und Grundeinstellungen vornehmen:
 +
[[Virtuelle Maschine einrichten UNIX-/Linux Netz (HAProxy)]]
 +
[[Virtuelle Maschine einrichten UNIX-/Linux Netz (www2)]]
 +
 
 +
# signiertes Wildcard-Zertifikat erstellen
 +
# 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 lab1''xx''.nux.key lab1''xx''.nux.crt > /etc/haproxy/server.pem'''
 +
* '''vim /etc/haproxy/haproxy.cfg'''
 +
==HA Proxy HTTP==
 +
frontend https_web_services
 +
  bind 10.0.1''xx''.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.1''xx''.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.1''xx''.2:80 check
 +
 +
backend backend_web2
 +
  timeout connect 5000
 +
  timeout server 50000
 +
  mode http
 +
  server web_ldap 10.0.1''xx''.3:80 check
 +
 +
backend http_backend
 +
  mode http
 +
  balance roundrobin
 +
  timeout connect 5000
 +
  timeout server 50000
 +
  server web_dns_2 10.0.1''xx''.2:80 check
 +
  server web_ldap_2 10.0.1''xx''.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 erste Schritte|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'''
 +
 
 +
{{#drawio:ul-tag-5}}
 +
 
 +
= 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 =
 +
 
 +
# Hostname auf ''health'' setzen
 +
# statische IP vergeben '''10.0.1''xx''.4/24'''
 +
# SSH Schlüssel hinterlegen
 +
# Eintrag im DNS Server vornehmen
 +
 
 +
= Checkmk =
 +
[[Virtuelle Maschine bereitstellen UNIX-LINUX Netzwerke (checkmk)]]
 +
* Die Weboberfläche soll über [https://cmk.lab1xx.nux https://cmk.lab1''xx''.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

Aktuelle Version vom 16. Mai 2025, 09:37 Uhr

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

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

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

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

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

SFTP zur sicheren Dateiübertragung

Virtuelle Maschine einrichten UNIX-/Linux Netz (SFTP)

HAProxy für zentrale SSL Terminierung

  • 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

  • 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

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)

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