Netzwerksicherheit Linuxhotel September 2018 (CentOS 7)

• vi (vim)
• mg (Micro Emacs)
• jove
• nano
• weitere Editoren können/dürfen nachinstalliert werden

• von einer MAC-Adresse zu einer IPv6 Adresse

08:00:27:ff:e8:ae

• von 48bit auf 64bit erweitern per "FFFE"

08:00:27:FF:FE:ff:e8:ae

• Bit 7 invertieren

0A:00:27:FF:FE:ff:e8:ae

• Link-Lokaler IPv6 Prefix anfuegen und als IPv6 Adresse schreiben

fe80::a27:ff:feff:e8ae

• vollständige IPv6 Adresse

fe80:0000:0000:0000:0a27:00ff:feff:e8ae

• ausprobieren: im tmux je eine neue Pane für Server und Client erstellen, und dort an die beiden anderen VMs verbinden
• Client:

ip link set up dev eth1
ping6 fe80::a00:ff:fe00:c0x%eth1
ssh nutzer@fe80::a00:ff:fe00:c0x%eth1

• Server

ip link set up dev eth2
ping6 fe80::a00:ff:fe00:f0x%eth2
ssh nutzer@fe80::a00:ff:fe00:f0x%eth2

• Hostnamen der Server VM äendern

hostnamectl set-hostname server0x
bash

• Hostnamen der Client VM äendern

hostnamectl set-hostname client0x
bash

• Geht ein 'ping' vom Server zum Client?
• Antwort: ohne IP-Forwarding: nein
• Forwarding anschalten (in der Quagga Shell auf dem Router)

vtysh
router0x# conf terminal
router0x(config)# ip forwarding
router0x(config)# ipv6 forwarding
router0x(config)# exit
route0x# write

• Geht ein 'ping' von Router ins Internet (1.0.0.1)? (auf dem Router ausführen)

ping 1.1

• geht ein 'ping' vom Server oder Client ins Internet (1.0.0.1)? (auf dem Server oder dem Client ausführen)

ping 1.1

• Lösung: iptables Masquerading NAT (auch Cone-NAT oder NATPT oder NAT44)
• auf dem Router in einer BASH-Shell (nicht im Quagga)

iptables -A POSTROUTING -t nat -o eth0 -j MASQUERADE

• Erstelle eine Host-Firewall-Regeln für den Router
  • ausgehend alle Verbindungen erlauben
  • eingehend auf eth0, eth1 und eth2 nur SSH (Port 22) und ICMPv4 erlauben
  • Verworfene Pakete in das syslog (Journal) schreiben
  • wer möchte kopiert seine Lösung in das Etherpad
• Log-Ausgaben anschauen

journalctl -e  # an das Ende des Journal-Log springen
journalctl -f  # an das Ende des Journals springen und neue Einträge sofort anzeigen (wie tail -f)

• Test der Firewall vom Laptop aus (d.h. diese Befehle direkt auf dem Laptop ausführen)

yum install nmap
nmap -sT -v -A -O 192.168.1.yyy # <ip-der-firewall>
ip route add 172.16.x.0/24 via <ip-des-Firewall-Routers>
nmap -sT -v -O 172.16.x.0/24 # <ip-netz-hinter-der-firewall>

router0x$ iptables-save > /etc/iptables.rules

• Datei /usr/local/sbin/iptables-flush

#!/bin/sh

iptables -P INPUT   ACCEPT
iptables -P OUTPUT  ACCEPT
iptables -P FORWARD ACCEPT

# bestehene Regeln löschen (Firewall Reset)
iptables -F
iptables -F -t nat

• Datei ausführbar machen

chmod +x /usr/local/sbin/iptables-flush

• Datei /etc/systemd/system/iptables.service

[Unit]
Description=Packet Filtering Framework
DefaultDependencies=no
After=systemd-sysctl.service
Before=sysinit.target
[Service]
Type=oneshot
ExecStart=/usr/sbin/iptables-restore /etc/iptables.rules
ExecReload=/usr/sbin/iptables-restore /etc/iptables.rules
ExecStop=/usr/local/sbin/iptables-flush
RemainAfterExit=yes
[Install]
WantedBy=multi-user.target

• Systemd-Unit-Dateien neu laden

systemctl daemon-reload

• iptables Unit ausprobieren

systemctl start iptables
iptables -L
systemctl stop iptables
iptables -L

• Firewall beim Neustart anschalten

systemctl enable iptables

• Test durch Reboot der Firewall-Maschine (Router)

router0x# reboot

• Firewall-Regeln aus dem Speicher sichern. Hiermit werden manuelle Änderungen an den Firewall-Regeln permanent gespeichert. Dies ist optional und nicht in allen Fällen erwünscht!
• Datei /usr/local/sbin/iptables-flush

#!/bin/sh
# Firewall-Regeln sichern
iptables-save > /etc/iptables.rules

# Default-Policy öffnen
iptables -P INPUT   ACCEPT
iptables -P OUTPUT  ACCEPT
iptables -P FORWARD ACCEPT

# bestehene Regeln löschen (Firewall Reset)
iptables -F
iptables -F -t nat

• SSH vom Router auf Client/Server erlauben, dafür die Zeilen

# bestehende eingehende Verbindungen aus dem Internet erlauben
iptables -A INPUT  -i eth0 -m state --state RELATED,ESTABLISHED -j ACCEPT

• ersetzen durch

# bestehende eingehende Verbindungen 
iptables -A INPUT  -m state --state RELATED,ESTABLISHED -j ACCEPT

• Testen, das der Client (VM) derzeit nicht DNS-Namensauflösung über den DNS-Resolver im Linuxhotel Netzwerk machen kann

ssh nutzer@172.16.x.2
dig @192.168.1.5 linuxhotel.de a ## <-- Timeout

• Erstelle Regeln, welche dem Client erlauben, per DNS Port 53 (UDP/TCP) auf den DNS-Resolver im Linuxhotel (192.168.1.17) zuzugreifen

iptables -A FORWARD  -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A FORWARD -s 172.16.x.0/24 -d 192.168.1.5 -p udp --dport 53 -j ACCEPT
iptables -A FORWARD -s 172.16.x.0/24 -d 192.168.1.5 -p tcp --dport 53 -j ACCEPT

• Test auf dem Client (VM)

client0x$ dig @192.168.1.5 linuxhotel.de A
; <<>> DiG 9.9.6-P1 <<>> @192.168.1.5 linuxhotel.de
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 12224
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;linuxhotel.de.                 IN      A

;; ANSWER SECTION:
linuxhotel.de.          3599    IN      A       217.69.87.63

;; Query time: 47 msec
;; SERVER: 192.168.1.5#53(192.168.1.17)
;; WHEN: Tue Jan 19 04:38:16 CET 2016
;; MSG SIZE  rcvd: 58

• DNS-Resolver in der /etc/resolv.conf auf der Client VM eintragen

client0x$ echo "nameserver 192.168.1.5" > /etc/resolv.conf

• welche weiteren Regeln müssen in der Firewall eingetragen werden, um Paketinstallationen auf dem Client per yum install zu erlauben
• erstelle die Regeln und teste das Paket links zu installieren (ein Text-Webbrowser) (yum install links)

[...]
iptables -A FORWARD -s 172.16.x.0/24  -p tcp --dport 80  -j ACCEPT
iptables -A FORWARD -s 172.16.x.0/24  -p tcp --dport 443 -j ACCEPT
[...]

router0x$ yum install iftop
router0x$ iftop -i eth0

• Taste p schaltet die Anzeige der UDP/TCP Ports an
• Taste n schaltet DNS-Rückwärtsauflösung für IP-Adressen aus

• Erstelle erweiterte Regeln für das Routing des Router
  • SSH von Client/Firewall zum Server erlauben
  • HTTP (Port 80) vom Client zum Server erlauben
  • DNS von Client und vom Server ins Internet erlauben
  • HTTP (80) und HTTPS (443) vom Client/Server ins Internet zulassen (fuer Software Updates)
  • Masquerading NAT für Verbindungen ins 'Internet'
  • vom Router DHCP ins Linuxhotel-Netz erlauben (Port 67/68 UDP)
  • keine anderen ausgehenden Verbindungen erlauben

• Zugriff vom Laptop zum Webserver auf der Server VM (in das Firewall-Skript an passender Stelle einbauen)

# HTTP vom Internet auf Server zulassen
iptables -A FORWARD -i eth0 -m state --state new -p tcp --dport 80 -j ACCEPT

• Auf dem Server eine kleine Webseite erzeugen und den Webserver starten

echo "dies ist der Server" > ~/index.html
cd ~
python -m SimpleHTTPServer 80

• Auf dem Laptop eine Route auf den Server setzen und testen

ip route add 100.64.x.0/24 via 192.168.1.xxx
links 100.64.x.2

• Auf dem Client (der hier die Rolle eines Backup-Webserver einnimmt) eine kleine Webseite erzeugen und den Webserver starten

echo "dies ist der Client" > ~/index.html
cd ~
python -m SimpleHTTPServer 80

• Backup DNAT um Anfragen an den Webserver 100.64.x.2 auf den Client "umzuleiten"

# HTTP per DNAT von Server auf den Client "umbiegen"
iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 80 \
    -j DNAT --to-destination 172.16.x.2

• Artificial Ignorance http://www.ranum.com/security/computer_security/papers/ai/
• Log-Templater
  • http://www.uberadmin.com/Projects/logtemplater/
  • https://github.com/rondilley/tmpltr

• Webseite: http://www.shorewall.net
• iptables Firewall stoppen (eigenes Skript)

systemctl stop iptables
systemctl disable iptables

• Installation unter CentOS

yum install shorewall

• /etc/shorewall/zones - firewall "zonen" (5 Zeichen)

#ZONE   TYPE    OPTIONS                 IN                      OUT
#                                       OPTIONS                 OPTIONS
fw      firewall
net     ipv4
loc     ipv4
dmz     ipv4

• /etc/shorewall/interfaces - Interface zu Host Zuordnung

?FORMAT 2
###############################################################################
#ZONE           INTERFACE               OPTIONS
net             eth0                    dhcp
loc             eth1
dmz             eth2

• /etc/shorewall/masq - Masquerading und SNAT

#INTERFACE:DEST         SOURCE          ADDRESS         PROTO   PORT(S) IPSEC   MARK    USER/   SWITCH  ORIGINAL
#                                                                                       GROUP           DEST
eth0:                   100.64.x.0/24,172.16.x.0/24

• /etc/shorewall/policy - generische Policy zwischen Zonen

#SOURCE         DEST            POLICY          LOG LEVEL       LIMIT:BURST
loc             net             ACCEPT
net             all             DROP            info
# THE FOLLOWING POLICY MUST BE LAST
all             all             REJECT          info

• /etc/shorewall/rules - Ausnahmen zu der Policy zwischen Zonen (Firewallregeln)

#ACTION         SOURCE          DEST            PROTO   DEST    SOURCE          ORIGINAL        RATE          USER/   MARK    CONNLIMIT       TIME            HEADERS         SWITCH          HELPER
#                                                       PORT    PORT(S)         DEST            LIMIT           GROUP
?SECTION ALL
?SECTION ESTABLISHED
?SECTION RELATED
?SECTION INVALID
?SECTION UNTRACKED
?SECTION NEW
# Kaputte Pakete stoppen
#
Invalid(DROP)   net             all             tcp

# DNS Firewall -> Internet
#
DNS(ACCEPT)     $FW             net
#
#
# SSH von Lokal zu DMZ, Firewall
#
SSH(ACCEPT)     loc             $FW
SSH(ACCEPT)     loc             dmz
#
# SSH von der Firewall zum Client, Server
##
SSH(ACCEPT)     $FW             loc
SSH(ACCEPT)     $FW             dmz
#
#
# SSH von Internet zu Firewall
#
SSH(ACCEPT)     net             $FW
#
# DNS aus der DMZ ins Internet
#
DNS(ACCEPT)     dmz             net
# Kein "ping" auf die Firewall
#
Ping(DROP)      net             $FW
#
# ping zwischen loc, firewall, dmz
#
Ping(ACCEPT)    loc             $FW
Ping(ACCEPT)    dmz             $FW
Ping(ACCEPT)    loc             dmz
Ping(ACCEPT)    dmz             loc
Ping(ACCEPT)    dmz             net
ACCEPT          $FW             net             icmp
ACCEPT          $FW             loc             icmp
ACCEPT          $FW             dmz             icmp

• /etc/shorewall/stoppedrules - Regeln aktiv wenn die Firewall gestoppt wird/ist

ACCEPT          eth0            -
ACCEPT          -               eth0
ACCEPT          eth1            -
ACCEPT          -               eth1
ACCEPT          eth2            -
ACCEPT          -               eth2

• /etc/shorewall/shorewall.conf - Globale Konfiguration des Shorewall Programms

[...]
STARTUP_ENABLED=yes

LOGFILE=/var/log/shorewall
[...]

• Shorewall starten

touch /var/log/shorewall
shorewall start

• die von Shorewall erzeugten iptables Regeln anzeigen

iptables -L
iptables -L -t nat 

• Shorewall stoppen (ACHTUNG! Stoprules sind aktiv)

shorewall stop

• Shorewall Regeln löschen (Firewall wird ausgeschaltet)

shorewall clear

• Shorewall Regeln/Verbindungen anzeigen

shorewall ls
shorewall ls connections
shorewall ls policies
shorewall ls routing

• Shorewall über Systemd starten/anschalten/stoppen

systemctl enable shorewall
systemctl start shorewall
systemctl stop shorewall

• Emacs ORG-Mode http://orgmode.org/
• Emacs ORG-Mode Babel http://orgmode.org/worg/org-contrib/babel/intro.html
• emacs und ruby installieren

yum install emacs-nox ruby

• Org-Babel-Dokument (, am Anfang der Zeilen entfernen, sind notwendig um Org-Mode innerhalb von einem Org-Mode Dokument einzubetten)

#+Title: Firewall-Tests
#+Language: de

* Babel anschalten                                                 :noexport:
#+BEGIN_EXAMPLE                                                                                          
(org-babel-load-languages                                                                                
(org-babel-do-load-languages 'org-babel-load-languages                                                   
  '((ruby . t)                                                                                           
))                                                                                                       
#+END_EXAMPLE                                                                                            

#+BEGIN_SRC ruby :exports results
require 'time'
"Dieser Firewalltest wurde am #{Time.now}
 auf Rechner #{`hostname`} erstellt"
#+END_SRC

#+RESULTS:
: Dieser Firewalltest wurde am 2016-11-30 09:10:09 +0100
:  auf Rechner csmobile4.home.strotmann.de
:  erstellt

* Firewall Regeln

Dies sind undere aktuellen Firewall Regeln

** INPUT Chain

*** Filter Tabelle

#+BEGIN_SRC ruby :exports results
`sudo iptables -L INPUT -t filter -v -n --line-numbers`
#+END_SRC

#+RESULTS:
#+begin_example
Chain INPUT (policy ACCEPT 0 packets, 0 bytes)
num   pkts bytes target     prot opt in     out     source               destination
1        0     0 ACCEPT     udp  --  virbr0 *       0.0.0.0/0            0.0.0.0/0            udp dpt:53
2        0     0 ACCEPT     tcp  --  virbr0 *       0.0.0.0/0            0.0.0.0/0            tcp dpt:53
3        0     0 ACCEPT     udp  --  virbr0 *       0.0.0.0/0            0.0.0.0/0            udp dpt:67
4        0     0 ACCEPT     tcp  --  virbr0 *       0.0.0.0/0            0.0.0.0/0            tcp dpt:67
5    63268   28M ACCEPT     all  --  *      *       0.0.0.0/0            0.0.0.0/0            ctstate RELATED,ESTABLISHED
6      591 41163 ACCEPT     all  --  lo     *       0.0.0.0/0            0.0.0.0/0
7     2655  631K INPUT_direct  all  --  *      *       0.0.0.0/0            0.0.0.0/0
8     2655  631K INPUT_ZONES_SOURCE  all  --  *      *       0.0.0.0/0            0.0.0.0/0
9     2655  631K INPUT_ZONES  all  --  *      *       0.0.0.0/0            0.0.0.0/0
10       0     0 DROP       all  --  *      *       0.0.0.0/0            0.0.0.0/0            ctstate INVALID
11     516 84169 REJECT     all  --  *      *       0.0.0.0/0            0.0.0.0/0            reject-with icmp-host-prohibited
#+end_example

* Firewall Tests

 * Können wir das Internet über Port 80 erreichen?

#+BEGIN_SRC ruby :exports both
`nmap -sT linuxhotel.de -p 80`
#+END_SRC

#+RESULTS:
:
: Starting Nmap 7.12 ( https://nmap.org ) at 2016-11-30 09:16 CET
: Nmap scan report for linuxhotel.de (217.69.87.63)
: Host is up (0.030s latency).
: rDNS record for 217.69.87.63: namebased-hostings.villa-vogelsang.de
: PORT   STATE SERVICE
: 80/tcp open  http
:
: Nmap done: 1 IP address (1 host up) scanned in 0.53 seconds

• Folien http://notes.defaultroutes.de/nftables.html
• auf der Router-VM arbeiten
• Shorewall stoppen wenn aktiv

systemctl stop shorewall
shorewall clear
iptables -L
iptables -L -t nat

• "nftables" auf dem Router installieren

yum install nftables

• root-Shell öffnen, ntf Version abfragen

sudo -s
nft -v

• das nftables Ruleset auflisten (sollte am Anfang leer sein)

nft list ruleset

• ein nft Ruleset für eine Host-Firewall, per Editor in die Datei /etc/nftables/inet-filter schreiben

# Regelsatz löschen
flush ruleset

# Variable "any" definieren
define any = 0::0/0

table inet filter {
        chain input {
                type filter hook input priority 0;

                # accept any localhost traffic
                iif lo accept

                # accept traffic originated from us
                ct state established,related accept

                # activate the following line to accept common local services
                tcp dport { 22, 80, 443 } ct state new accept

                # NTP multicast
                ip6 daddr ff02::1010 udp dport 123 accept

                # mDNS (avahi)
                ip6 daddr ff02::fb udp dport 5353 accept
                ip  daddr 224.0.0.251 udp dport 5353 accept

                # DHCPv6
                ip6 saddr $any udp dport 546 accept

                # IPP (CUPS)
                udp dport 631 accept

                # Accept neighbour discovery otherwise IPv6 connectivity breaks.
                ip6 saddr $any icmpv6 type { nd-neighbor-solicit,  
                                             nd-router-advert, 
                                             nd-neighbor-advert }  accept

                # Accept essential icmpv6
                ip6 saddr $any icmpv6 type { echo-reply, 
                                             echo-request, 
                                             packet-too-big, 
                                             destination-unreachable, 
                                             time-exceeded, 
                                             parameter-problem } accept

                # count and drop any other traffic
                counter log prefix "nftables drop: " drop
        }
}

• Filter include "/etc/nftables/inet-filter" in der Datei /etc/sysconfig/nftables.conf einkommentieren
• nftables Firewall laden

systemctl start nftables

• Regelwerk anzeigen

nft list ruleset

• Log-Ausgaben anzeigen

journalctl -f | grep nftables

• eigenen Router vom Laptop aus mit nmap scannen (einmal mit nftables Firewall, einmal mit der nftables Firewall ausgeschaltet. Gibt es einen Unterschied?)

nmap -sT 192.168.1.xxx # <--- IP Adresse des Routers

• Installationsinformationen für Wireguard https://www.wireguard.com/install/
• Die wg-quick Funktion von Wireguard ist derzeit unter CentOS/RedHat 7.x nicht benutzbar (Kernel zu alt -> https://lists.zx2c4.com/pipermail/wireguard/2018-June/003081.html). Wir benutzen hier eine alternative Routing-Lösung.
• die Router-VM ist unser Wireguard-Client
• Derzeit ist Wireguard noch nicht in den Linux-Kernel eingezogen, soll aber in Version 4.20/5.00 in den Kernel kommen
• Wireguard Repository Quellen laden, EPEL-Repository hinzufügen und Wireguard-Pakete installieren

sudo -s

curl -Lo /etc/yum.repos.d/wireguard.repo \
 https://copr.fedorainfracloud.org/coprs/jdoss/wireguard/repo/epel-7/jdoss-wireguard-epel-7.repo

yum install epel-release

yum install wireguard-dkms wireguard-tools

• Firewall ausschalten (oder besser: eine Regel für den Wireguard Port (UDP) erstellen)

systemctl stop firewalld

• Verzeichnis für die Wireguard-Dateien erstellen

mkdir /etc/wireguard
cd /etc/wireguard

• einen privaten Schlüssel für den Wireguard-Dienst erstellen

wg genkey > private.key

• Berechtigungen auf dem privaten Schlüssel anpassen

chmod 0400 private.key

• Wireguard-Interface erstellen

ip link add dev wg0 type wireguard

• IP-Adresse auf dem neuen Wireguard-Interface wg0 setzen

ip addr add 10.0.0.2/24 dev wg0

• Privaten Schlüssel in das wg0 Interface laden

wg set wg0 private-key ./private.key

• Interface wg0 aktivieren

ip link set wg0 up

• Konfiguration der Schnittstelle anzeigen

wg show wg0

• der Router ist unser VPN-Client
• Verzeichnis für die Wireguard-Dateien erstellen

mkdir /etc/wireguard
cd /etc/wireguard

• einen privaten Schlüssel für den Wireguard-Dienst erstellen

wg genkey > private.key

• Berechtigunen auf dem privaten Schlüssel anpassen

chmod 0400 private.key

• Wireguard-Interface erstellen

ip link add dev wg0 type wireguard

• IP-Adresse auf dem neuen Wireguard-Interface wg0 setzen

ip addr add 10.0.0.1/24 dev wg0

• Privaten Schlüssel in das wg0 Interface laden

wg set wg0 private-key ./private.key

• Interface wg0 aktivieren

ip link set wg0 up

• öffentlicher Schlüssel, erlaubte IP-Adressen und IP/Port des VPN-Servers eintragen

wg set wg0 peer <schlüssel> allowed-ips 0.0.0.0/0 endpoint <vpn-server>:<port>

• Konfiguration der Schnittstelle anzeigen

wg show wg0

• Konfiguration in die Konfigurationsdatei speichern

wg showconf wg0 > /etc/wireguard/wg0.conf
chmod 0600 /etc/wireguard/wg0.conf

• Konfigurationsdatei

[Interface]
ListenPort = <port>
PrivateKey = <private-key>

[Peer]
PublicKey = <public-key>
AllowedIPs = 0.0.0.0/0
Endpoint = <ip-of-vpn-server>:<port>

• Konfiguration laden

wg setconf wg0 /etc/wireguard/wg0.conf

• auf dem VPN-Server, die Wireguard-Configuration speichern

wg showconf wg0 > /etc/wireguard/wg0.conf
chmod 0600 /etc/wireguard/wg0.conf

• Konfigurationsdatei anpassen (Abschnitt Peer)

[Interface]
ListenPort = <port>
PrivateKey = <private-key>

[Peer]
PublicKey = <public-key-of-client>
AllowedIPs = 10.0.0.1/32

• Konfiguration laden

wg setconf wg0 /etc/wireguard/wg0.conf

iptables -A POSTROUTING -t nat -o eth0 -j MASQUERADE
echo 1 > /proc/sys/net/ipv4/ip_forward
echo 'net.ipv4.ip_forward=1' >> /etc/sysctl.conf

• Ping vom VPN-Client Wireguard-IP zum VPN-Server

ping 10.0.0.2

• der DNS-Resolver des Linuxhotels ist über den Tunnel nicht erreicbar, daher müssen wir einen DNS-Resolver im Internet benuzten (oder, besser, einen eigenen DNS-Resolver auf dem VPN-Gateway-Server).

echo "nameserver 1.1.1.1" > /etc/resolv.conf

• Alle Pakete (mit Aussnahme der Wireguard Pakete) sollen durch den VPN-Tunnel gesendet werden. Eine Split-Default-Route sorgt dafür, das wir die original Default-Route nicht verlieren

ip route add <ip-des-VPN-servers>/32 via 192.168.1.5 dev eth0
ip route add  0.0.0.0/1 via 10.0.0.2 dev wg0
ip route add  128.0.0.0/1 via 10.0.0.2 dev wg0

• Test

# tracepath google.com
 1?: [LOCALHOST]                                         pmtu 1420
 1:  10.0.0.2                                             15.453ms 
 1:  10.0.0.2                                             15.446ms 
 2:  no reply
 3:  45.63.118.33                                         18.164ms 
 4:  no reply
 5:  ffm-b12-link.telia.net                               20.718ms 
 6:  ffm-bb4-link.telia.net                               15.889ms 
 7:  ffm-b1-link.telia.net                                16.062ms 
 8:  google-ic-319727-ffm-b1.c.telia.net                  15.997ms asymm 10
[...]

• Routen löschen

ip r del 0.0.0.0/1 via 10.0.0.2 dev wg0
ip r del 128.0.0.0/1 via 10.0.0.2 dev wg0
ip r del <ip-des-vpn-servers> via 192.168.1.5 dev eth0

• Wireguard Interface ausschalten

ip link set dev wg0 down

• Folien https://notes.defaultroutes.de/tls.html

• NGINX installieren (CentOS VPS), Passwort netsec09 (root)

ssh root@vm0X.defaultroutes.de

• NGINX Webserver installieren

yum install nginx

• OpenSSL Schlüssel erstellen und selbst signieren, als Common-Name den Namen des Servers eintragen vm0x.defaultroutes.de
• RSA-Privaten Schluessel erstellen (2048 bit)

openssl genrsa -out vm0X.defaultroutes.de.private 2048

• oeffentlichen RSA-Schluessel erzeugen

openssl rsa -in vm0X.defaultroutes.de.private -pubout -out vm0X.defaultroutes.de.public
openssl rsa -text -pubin -in vm0X.defaultroutes.de.public | less

• OpenSSL Konfigurationsdatei für Zertifikatserstellung vm0X.defaultroutes.de.conf

[req]
prompt = no
distinguished_name = dn
req_extensions = ext

[dn]
CN = vm0X.defaultroutes.de
emailAddress = teilnehmer@example.com
O = Linuxhotel
L = Essen
C = DE

[ext]
subjectAltName = DNS:vm0X.defaultroutes.de,DNS:www.vm0X.defaultroutes.de

• Self-Signed-Cert ohne CSR (Certificate Signing Request)

openssl req -new -x509 -config vm0X.defaultroutes.de.conf -days 365 \
     -key vm0X.defaultroutes.de.private -out vm0X.defaultroutes.de.crt

• Zertifikat und privaten Schlüssel in das Verzeichnis /etc/tls kopieren (Verzeichnis ggf. erstellen)

cp vm0X.defaultroutes.de.crt vmX.defaultroutes.private /etc/tls

• SSL/TLS Konfiguration, Datei /etc/nginx/nginx.conf

[...]
        listen 80 default_server;
        listen [::]:80 default_server;

        # SSL configuration
        #
        listen 443 ssl;
        listen [::]:443 ssl;
        ssl_certificate    /etc/tls/vm0X.defaultroutes.de.crt;
        ssl_certificate_key /etc/tls/vm0X.defaultroutes.de.private;
[...]

• NGINX-Konfiguration testen

nginx -t

• NGINX Webserver neu starten

systemctl restart nginx
systemctl status nginx
netstat -tulpen # <-- nginx Prozess sollte auf Port 80 und 443 lauschen
lsof -Poni :443 # <-- Alternative zu "netstat -tulpen"

• Mit den Firefox des Laptops auf die Webseite https://vm0X.defaultroutes.de gehen. Es sollte eine Zertifikatswarnung angezeigt werden (weil das Zertifikat über keines der Root-CAs im Browser prüfbar ist). Schaut Euch im Browser die Informationen über das Zertifikat an.
• Benutze openssl s_client auf dem Laptop um das Server-Zertifikat aus dem Webserver zu lesen und lokal zu speichern. Benutze openssl x509 um den Inhalt des Zertifikats anzuzeigen

• Um alle Anfragen auf Port 80 (ohne Verschlüsselung) auf eine verschlüsselte Verbindung umzulenken, bauen wir in der NGINX-Konfiguration ein Redirect von HTTP auf HTTPS

server {
        listen 80 default_server;
        listen [::]:80 default_server;
        # redirect zum HTTPS Server
        return 301 https://$server_name/$request_uri;
        root /var/www/html;
        index index.html index.htm index.nginx-debian.html;
        server_name vmX.defaultroutes.de;
        location / {
                try_files $uri $uri/ =404;
        }
}
server {
        # SSL configuration
        #
        listen 443 ssl;
        listen [::]:443 ssl;
        ssl_certificate    /etc/tls/vmX.defaultroutes.de.crt;
        ssl_certificate_key /etc/tls/vmX.defaultroutes.de.private;
        root /var/www/html;
        index index.html index.htm index.nginx-debian.html;
        server_name _;
        location / {
                try_files $uri $uri/ =404;
        }
}

• Let's Encrypt Zertifikate lassen sich automatisiert abrufen
• ACME steht für Automatic Certificate Management Environment und wird derzeit in der IETF standardisiert https://datatracker.ietf.org/doc/draft-ietf-acme-acme/
• Es gibt verschiedene ACME-Clients
  • der offizielle ACME-Client von Let's Encrypt (viele Abhängigkeiten) https://github.com/certbot/certbot
  • Google ACME Client ohne Abhängigkeiten https://github.com/google/acme
  • LEGO - ACME Client in Go https://github.com/xenolf/lego
  • dehydrated - ACME Client als Shell-Script https://github.com/lukas2511/dehydrated
  • acme.sh - ACME Client als Shell-Skript mit Schnittstellen zu DNS-Hosting-Providern und nsupdate https://github.com/Neilpang/acme.sh
  • OpenBSD acme-client (sehr sichere Architektur) https://kristaps.bsd.lv/acme-client/

• wir arbeiten auf der VM im Internet
• NGINX (und andere Server auf Port 80/443) stoppen

systemctl stop nginx

• Webseite https://caddyserver.com
• Vorbereitetes Caddy-Paket vom Schulungsserver laden

sudo -s
cd /srv
wget https://notes.defaultroutes.de/caddy.tgz

• Caddy auspacken (Caddy ist in Go geschrieben, ist ein statisches Programm und muss nicht installiert werden)

tar xvfz caddy.tgz
rm caddy.tgz

• Caddy Konfigurationsdatei vi Caddyfile

vm0x.defaultroutes.de {
        gzip
        tls nutzerXX@linuxhotel.de
        root /srv/website
}

• Webseite erstellen

mkdir /srv/website
echo "Meine erste Caddy-Webseite" > /srv/website/index.html

• Caddy starten

./caddy

• Webseite im Firefox testen https://vm0x.defaultroutes.de/ Zertifikat anschauen

• Signalisiert zum Browser das dieser Server für eine Zeitspanne TLS unterstützen wird
  • Browser 'lernen' und speichern die HSTS-Informationen
  • erster Besuch auf einer TLS-gesicherten Seite ist noch nicht durch HSTS geschützt
  • HSTS Zertifikatsfehler sind fatal (der Benutzer hat keine Möglichkeit des 'click-through' um den Zertifikatsfehler zu umgehen und die Seite trotzdem zu laden)
  • Beispiel-Konfiguration für NGINX

add_header Strict-Transport-Security max-age=15768000; # HSTS fuer 6 Monate

• Security-Header prüfen: https://securityheaders.com

• TLS Protokol Unterstützung testen

openssl s_client -connect www.example.com:443 -tls1_2

• TLS Cipher Untertützung testen

openssl ciphers
openssl s_client -connect www.example.com:443 -cipher RC4-SHA

• TLS Protokol Auswahl bei Nginx

ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # not possible to do exclusive

• Cipher Auswahl (nginx)

ssl_prefer_server_ciphers on;
ssl_ciphers 'EDH+CAMELLIA:EDH+aRSA:EECDH+aRSA+AESGCM:EECDH+aRSA+SHA256:EECDH:\
	     +CAMELLIA128:+AES128:!aNULL:!eNULL:!LOW:!3DES:!MD5:!EXP:!PSK:!DSS:!RC4:\
	     !SEED:!IDEA:!ECDSA:kEDH:CAMELLIA128-SHA:AES128-SHA';

• Beispiel TLS-Handshake bei Postfix Mailserver

Jun  7 18:18:43 m3 postfix/smtp[32096]: Untrusted TLS connection established to mx02.t-online.de[194.25.134.9]:25: TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)
Jun  7 18:18:43 m3 postfix/smtp[32095]: Verified TLS connection established to mx01.emig.gmx.net[212.227.17.5]:25: TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)

• Installation (auf Client und Server)

$ yum install stunnel

• Client stunnel Konfiguration in /etc/stunnel/stunnel.conf

client  = yes
debug   = info
output  = /var/log/stunnel.log

; These options provide additional security at some performance degradation
options = SINGLE_ECDH_USE
options = SINGLE_DH_USE

[http-to-https]
accept  = 80
connect = 100.64.x.2:8000
cert    = /etc/stunnel/stunnel.pem

• Server stunnel Konfiguration in /etc/stunnel/stunnel.conf

debug = info
output = /var/log/stunnel.log

; These options provide additional security at some performance degradation
options = SINGLE_ECDH_USE
options = SINGLE_DH_USE
[https-8000]
accept  = 8000
connect = localhost:8001
cert = /etc/stunnel/stunnel.pem

• systemd unit in /etc/systemd/system/stunnel.service on the server

### stunnel.service

[Unit]
Description=Stunnel service
After=network.target

[Service]
Type=forking
ExecStart=/usr/bin/stunnel /etc/stunnel/stunnel.conf
Restart=always

[Install]
WantedBy=Default.target

• x509 Zertifikat erstellen

$ openssl req -new -nodes -x509 -out /etc/stunnel/stunnel.pem \
  -keyout /etc/stunnel/stunnel.pem
$ chmod 400 /etc/stunnel/stunnel.pem

• Systemd Unit auf dem Server starten

$ systemctl daemon-reload
$ systemctl enable --now stunnel

• Webserver auf dem Server auf Port 8001 starten

server0x$ python -m SimpleHTTPServer 8001

• Start des stunnel auf dem Client

$ stunnel
$ tail /var/log/stunnel.log
$ lsof -i | grep stunnel

• Test der Verbindung, links verbindet sich per HTTP unverschlüsselt, stunnel bietet die TLS Verschlüsselung (per tcpdump auf dem Router schauen das die Pakete SSL/TLS verschluesselt sind)

$ links http://localhost

• per tcpdump auf dem Router testen, das kein HTTP oder HTTPS Verkehr zu sehen ist

tcpdump -nn -i eth1 port 80 or 443 or 8000

• Server stunnel Konfiguration in /etc/stunnel/stunnel.conf anpassen (Abschnitt [https])

debug = info
output = /var/log/stunnel.log

; These options provide additional security at some performance degradation
options = SINGLE_ECDH_USE
options = SINGLE_DH_USE
[https-8000]
accept  = 8000
connect = localhost:8001
cert = /etc/stunnel/stunnel.pem
[https]
accept  = 443
connect = localhost:8001
cert = /etc/stunnel/stunnel.pem

• stunnel auf dem Server neu starten

systemctl restart stunnel

• mit dem links Webbrowser testen (Protokoll HTTPS/TLS). Hier gibt es eine Zertifikats-Warnung, da der stunnel auf dem Server ein Self-Signed Zertifikat verwendet

links https://100.64.x.2

• Auf dem Laptop arbeiten
• In /etc/yum.repos.d/CentOS-Base.repo die Plus- und Extra-Repositories aktivieren (enable=1), EPEL-Release (Extra-Packages-for-RedHat-Linux)

yum install epel-release

• Privoxy Homepage http://privoxy.org
• Privoxy horcht auf Port 8118
• "action" –> was soll mit einer URL passieren (blocken, filtern etc)?
• "filter" –> wie soll Inhalte umgeschrieben werden?

$ yum install privoxy
$ systemctl enable privoxy
$ systemctl start privoxy

• Konfiguration

$ vi /etc/privoxy/config
$ vi /etc/privoxy/default.action
$ vi /etc/privoxy/user.action
$ vi /etc/privoxy/default.filter
$ vi /etc/privoxy/user.filter

• Firefox Browser umkonfigurieren, so das als Proxy fuer HTTP/HTTPS localhost Port 8118 benutzt wird
• Example "user.action" Datei https://gist.github.com/sx2008/2766874
• Privoxy-Webkonfiguration http://config.privoxy.org oder http://p.p
• Panopticlick Browser-Fingerprint Test https://panopticlick.eff.org

• Docker installieren (auf dem Laptop)

yum install docker

• Docker starten

systemctl enable --now docker

• OpenVAS laden und starten

docker run -d -p 443:443 --name openvas mikesplain/openvas

• Logs anzeigen bis OpenVAS geladen ist und die Meldung openvassd 5.1.2 started angezeigt wird:

docker logs -f openvas

• Mit dem Firefox Browser auf https://localhost (Benutzer admin, Passwort admin) am OpenVAS anmelden.
• Mit dem Task Wizard einen neuen Scan starten (unter Scans). IP-Adresse des Laptops des Trainers (192.168.1.213) angeben. Der Scan dauert mehrere Minuten.

• NSS-Datenbank initialisieren

ipsec initnss --nssdir /etc/ipsec.d

• IPSEC Schlüssel auf dem Client erstellen

ipsec newhostkey --output /etc/ipsec.secrets
Generated RSA key pair with CKAID <ckaid> was stored in the NSS database

• Schlüssel anzeigen (wird in der Konfiguration benötigt)

ipsec showhostkey --left --ckaid <ckaid>
        # rsakey AwEAAei9b
        leftrsasigkey=0sAwEA[...]sadas==

• NSS-Datenbank initialisieren

ipsec initnss --nssdir /etc/ipsec.d

• IPSEC Schlüssel auf dem Client erstellen

ipsec newhostkey --output /etc/ipsec.secrets
Generated RSA key pair with CKAID <ckaid> was stored in the NSS database

• Schlüssel anzeigen (wird in der Konfiguration benötigt)

ipsec showhostkey --right --ckaid <ckaid>
        # rsakey AwEAAei9b
        rightrsasigkey=0sAwEA[...]sadas==

• Konfigurationsdatei für diese IPSec-Verbindung auf beiden Rechnern in der Datei /etc/ipsec.d/host-to-host.conf erstellen:

conn host-to-host
 left=172.16.x.2
 leftrsasigkey=0sAwEAAe[...]
 right=100.64.x.2
 authby=rsasig
 rightrsasigkey=0sAwEAA[...]
 #auto=start, ondemand, add
 auto=add
 ikev2=insist

• auf beiden Rechner IPSec starten und Tunnel host-to-host starten

ipsec start
ipsec auto --add host-to-host
ipsec auto --up host-to-host

• tcpdump auf dem Router darf nur ESP Pakete sehen, keine ICMP Pakete

tcpdump -v -i eth1 icmp   # <-- keine Pakete zu sehen
tcpdump -v -i eth1 esp    # <-- IPSec Pakete sehen

• Ping vom Server zum Client

ping -c4 172.16.x.2

• Ping von Client zum Server

ping -c4 100.64.x.2

• IPSec Status

ipsec status

• Verbindungsstatus anschauen

ipsec whack --trafficstatus

• IPSec Verbindungsinformationen im Kernel

ip xfrm state

• IPSec Verschlüsselungs-Policy im Kernel anzeigen (welche Verbindungen sind durch IPSec geschützt)

ip xfrm policy

• ESP, IKEv1 und IKEv2 im tcpdump sehen

tcpdump -n esp or port 500 or port 4500 -i eth0 

• IPSec Tutorial von der NetDev 0x12 (2018)
  • Slides https://www.files.netdevconf.org/d/a18e61e734714da59571/
  • Video https://www.youtube.com/watch?v=7oldcYljp4U

• auf dem Laptop arbeiten
• In /etc/yum.repos.d/CentOS-Base.repo die Plus- und Extra-Repositories aktivieren (enable=1), EPEL-Release (Extra-Packages-for-RedHat-Linux) und TOR installieren

yum install epel-release
yum install tor
systemctl enable --now tor

• den Tor-Browser von Tor-Projekt installieren ( http://www.torproject.org ) oder den Socksv5-Proxy im Browser auf Port 9050 einstellen

• Onion Hidden-Service auf Localhost Port 8000

$EDITOR /etc/tor/torrc
[...]
HiddenServiceDir /var/lib/tor/hidden_service/
HiddenServicePort 80 127.0.0.1:8000
[...]

• Tor neu starten

systemctl restart tor
systemctl status tor

• Service staren

python -m SimpleHTTPServer

• den Onion-Namen herausfinden (Datei /var/lib/tor/hidden_service/hostname) und an einen der Teilnehmer weitergeben
• einen Onion-Dienst ansprechen (per Socks-Proxy) aus einem Browser

• Einige Server-Dienste schalten spezielle Admin-Funktionen frei, wenn der Server über eine Loopback-Adresse (127.0.0.1) angesprochen wird (z.B. der Apache Webserver –> https://www.heise.de/security/meldung/Apache-verpetzt-moeglicherweise-Tor-Hidden-Services-3090218.html). Bei Bennutzung als Tor-Dienst auf einer Loopback-Adresse sind diese Admin-Funktionen von aussen über das Tor-Netzwerk erreichbar. Lösung: den Dienst auf einer nicht-Loopback Adresse konfigurieren, oder die speziellen Admin-Funktionen in der Server-Konfiguration ausschalten.

Der Onion-Dienst, wie oben beschrieben, ist erreichbar für jeden Benutzer der den Onion-Namen kennt. Ein Onion-Name besteht derzeit aus 16 Zeichen (80 bit) und kann u.U. erraten werden. Um die Sicherheit des Onion-Dienstes noch weiter zu erhöhen, kann der Dienst mit einer Authentisierung versehen werden. Bei der Authentisierung bekommt jeder Client einen eigenen kryptografischen Schlüssel zugewiesen, und nur wenn dieser Schlüssel beim Verbindungsaufbau mit angegeben wird, ist der Onion-Dienst erreichbar (und sichtbar). Der Schlüssel ist ein Authentisierungs-Cookie aus 16 Bytes (Base64 kodiert) welcher zusätzlich zum Onion-Namen bekannt sein muss.

• keine Änderungen an der (Heim-)Firewall notwendig. Keine Port-Forwardings etc.
• kein DynDNS notwendig, um eine wechselne IP-Adresse mit einen Namen zu verbinden. Der Onion-Name wird immer im Tor-Netz gefunden
• Datenverkehr ist (einfach) verschlüsselt (1024bit RSA)
• Datenverkehr ist anonymisiert

• Client muss die Tor-Software als Proxy benutzen
• nur IPv4, kein IPv6 (daran wird gearbeitet)
• hohe Latenz (Verzögerung) bei den Paketlaufzeiten
• Tor-Verschlüsselung von 1024bit RSA nicht mehr zeitgemäß (auch daran wird im Tor-Projekt gearbeitet)

• Michael W. Lucas – SSH Mastery https://www.michaelwlucas.com/nonfiction/ssh-mastery
• Michael W. Lucas – PGP & GPG https://www.michaelwlucas.com/nonfiction/pgp-gpg-email-for-the-practical-paranoid
• Christof Paar, Jan Pelzl – Understanding Cryptography ISBN: 3642446493
• Klaus Schmeh – Kryptografie ISBN: 3864900158
• Niels Ferguson, Bruce Schneier, Tadayoshi Kohno – Cryptography Engineering ISBN: 0470474246
• Malcolm Harkins – Managing Risk and Information Security ISBN: 1430251131
• Ross Anderson – Security Engineering (PDF: http://www.cl.cam.ac.uk/~rja14/book.html)
• Steven Bellovin – Thinking Security: Stopping Next Year's Hackers (Addison-Wesley Professional Computing) ISBN-10: 0134277546/ISBN-13: 978-0134277547
• Mastering OpenVPN - Packt
• VPNs Illustrated: Tunnels, VPNs, and IPsec byJon C. Snader
• Linux-Firewalls - Ein praktischer Einstieg, 2. Auflage http://www.oreilly.de/german/freebooks/linuxfire2ger/toc.html
• Applied Crypto Hardening Dokument https://bettercrypto.org/

• http://www.linuxsecurity.com/resource_files/documentation/tcpip-security.html
• Defending against Sequence Number Attacks https://tools.ietf.org/html/rfc6528
• ICMPv6 Filtering Recommendations https://www.ietf.org/rfc/rfc4890.txt
• Reflections on Host Firewalls https://tools.ietf.org/html/rfc7288
• RedHat VPN https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/7/html/Security_Guide/sec-Securing_Virtual_Private_Networks.html
• Shorewall http://shorewall.net/three-interface.htm
• Strongswan https://www.strongswan.org/documentation.html
• IPSEC VPN on Centos 7 with StrongSwan https://raymii.org/s/tutorials/IPSEC_vpn_with_CentOS_7.html
• Ubuntu IPSec HowTo (IPSec Tools) https://help.ubuntu.com/community/IPSecHowTo
• HTTP Security Header Test https://securityheaders.com/