Netzwerksicherheit Linuxhotel April 2019 (Debian)

• emacs
• vi (vim)
• mg (Micro Emacs)
• jove
• nano
• joe
• 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 enp0s8
ping6 fe80::a00:ff:fe00:c0x%enp0s8
ssh nutzer@fe80::a00:ff:fe00:c0x%enp0s8

• Server

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

• Hostnamen der Server VM ändern

hostnamectl set-hostname server0x
bash

• Hostnamen der Client VM ändern

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 genannt)
• auf dem Router in einer BASH-Shell (nicht im Quagga)

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

• nach dem Eintragen des NAT nochmals Testen, ob ein 'ping' vom Client und Server in das Internet funktioniert

• BIND 9 auf dem Router installieren, um eine Server Anwendung auf dem Router zu haben

apt install bind9 dnsutils
systemctl start bind9

• Erstelle eine Host-Firewall-Regeln für den Router
  • ausgehend alle Verbindungen erlauben
  • eingehend auf enp0s3, enp0s8 und enp0s9 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)

• Erweitere die Firewall, so das DNS-Anfragen (Port 53) vom Laptop zum Router möglich sind
• Firewall-Regeln neu laden und dann die Firewall testen (vom Laptop aus)

dig @<ip-des-routers> txt chaos authors.bind
dig +tcp @<ip-des-routers> txt chaos version.bind

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

apt install nmap
nmap -sT -v -A 192.168.1.yyy # <ip-der-firewall>
ip route add 172.16.x.0/24 via <ip-des-Firewall-Routers>
nmap -sT -v -A 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=IPTables Packet Filtering Framework
DefaultDependencies=no
After=systemd-sysctl.service
Before=sysinit.target
[Service]
Type=oneshot
ExecStart=/sbin/iptables-restore /etc/iptables.rules
ExecReload=/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

• 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 enp0s3 -m state --state RELATED,ESTABLISHED -j ACCEPT

• ersetzen durch

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

• Erstelle Regeln, welche dem Client erlauben, per DNS Port 53 (UDP/TCP) auf den DNS-Resolver im Linuxhotel (192.168.1.5) 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
[...]

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

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

• Test der Namensauflösung

ping one.one.one.one

• eine Regel in der Chain FORWARD für icmp (IPv4) hinzufügen, damit der ping auch das Internet erreicht

iptables -A FORWARD -s 172.16.x.0/24 -d 192.168.1.5 -p icmp -j ACCEPT

• welche weiteren Regeln müssen in der Firewall eingetragen werden, um Paketinstallationen auf dem Client per apt install zu erlauben?
• erstelle die Regeln und teste die Pakete dnsutils und links zu installieren (ein Text-Webbrowser) (apt install links dnsutils)
• Testen, das der Client (VM) DNS-Namensauflösung über den DNS-Resolver im Linuxhotel-Netzwerk machen kann

ssh nutzer@172.16.x.2

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

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

router0x$ apt install iftop
router0x$ iftop -i enp0s3

• 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) 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 enp0s3 -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 dann per Firefox auf die URL http://100.64.x.2 gehen

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

• 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 enp0s3 -p tcp --dport 80 \
    -j DNAT --to-destination 172.16.x.2

• Alternative, wenn das Ziel eine Anwendung auf der Firewall-Maschine ist

iptables -A PREROUTING -t nat -i enp0s3 -p tcp --dport 80 \
    -j REDIRECT --to-port 3128

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

apt 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             enp0s3                    dhcp
loc             enp0s8
dmz             enp0s9

• /etc/shorewall/masq - Masquerading und SNAT

#INTERFACE:DEST         SOURCE          ADDRESS         PROTO   PORT(S) IPSEC   MARK    USER/   SWITCH  ORIGINAL
#                                                                                       GROUP           DEST
enp0s3:                 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          enp0s3            -
ACCEPT          -               enp0s3
ACCEPT          enp0s8            -
ACCEPT          -               enp0s8
ACCEPT          enp0s9            -
ACCEPT          -               enp0s9

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

apt 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-Dokumentation
#+Language: de

* Babel anschalten                                                 :noexport:
#+BEGIN_EXAMPLE                                                                                          
(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 unsere 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
• PDF-Druck Version für Chrome http://notes.defaultroutes.de/nftables.html?print-pdf
• 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

apt install nftables

• root-Shell öffnen, ntf Version abfragen

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.conf 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)
                tcp 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
        }
}

• 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 eingeschaltet, danach mit der nftables Firewall ausgeschaltet. Gibt es einen Unterschied?)

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

• HMAC-MD5 Authentisierung der OSPF-Kommunikation einschalten. Es wird ein "Shared-Secret" verwendet, hier das Wort "VILLA". Aus dem Wort und den Daten wird eine Signatur für die OSPF Pakete erzeugt. Auf allen OSPF-Routern (einer Area) muss das gleiche Secret konfiguriert werden.

router0x$ vtysh
router0x# conf terminal
router0x(config)# interface enp0s3
router0x(config-if)# ip ospf authentication message-digest
router0x(config-if)# ip ospf message-digest-key 1 md5 VILLA
router0x(config-if)# exit
router0x# router ospf
router0x(config-router)# area 0 authentication message-digest
router0x(config-router)# exit
router0x(config)# exit
router0x# write
router0x# debug ospf packet all

• Test: einen Server oder Router eines der anderen Teilnehmer per 'ping' erreichen (oder SSH).

• OSPF ist ein eigenes IP Protokoll (wie UDP oder TCP). Die Protokollnummer ist 89, der Protokoll-Name kann in der Datei /etc/protcols gefunden werden

grep ospf /etc/protocols

• Beispiel OSPF Regel

iptables -A INPUT  -p ospf -s <Quell-Netzwerk> -j ACCEPT
iptables -A OUTPUT -p ospf -d 224.0.0.0/24     -j ACCEPT

• Erweitere das IPTables Firewall Regelwerk für OSPF, starte danach den OSPFd Dienst auf dem Router neu un prüfe, ob der Routing-Dienst weiterhin die anderen Router "sehen" kann. Prüfe die Firewall-Logs auf neue Block-Meldungen.

• Installationsinformationen für Wireguard https://www.wireguard.com/install/
• Derzeit ist Wireguard noch nicht in den Linux-Kernel eingezogen, soll aber in Version ~5.2 in den Kernel kommen
• der Laptop ist unser Wireguard-Client
• auf dem Laptop und auf dem VPS Server im Internet das Wireguard Repository hinzufügen, Paketlisten updaten und Wireguard-Pakete installieren

echo "deb http://deb.debian.org/debian/ unstable main" > /etc/apt/sources.list.d/unstable.list
printf 'Package: *\nPin: release a=unstable\nPin-Priority: 90\n' > /etc/apt/preferences.d/limit-unstable
apt update
apt install wireguard

• User-Mask für neue Dateien und Verzeichnisse setzen, ein Verzeichnis für die Wireguard-Dateien erstellen

umask 077
mkdir /etc/wireguard
cd /etc/wireguard

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

wg genkey > 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 Laptop ist unser VPN-Client
• Wireguard installieren. Wurde ein neuer Linux-Kernel installiert, dann nach der Installation von Wireguard den Rechner neu starten, denn die Wireguard-Kernel-Module wurden schon für die neue Kernel-Version gebaut

echo "deb http://deb.debian.org/debian/ unstable main" > /etc/apt/sources.list.d/unstable.list
printf 'Package: *\nPin: release a=unstable\nPin-Priority: 90\n' > /etc/apt/preferences.d/limit-unstable
apt update
apt install wireguard

• Verzeichnis für die Wireguard-Dateien erstellen

umask 077
mkdir /etc/wireguard
cd /etc/wireguard

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

wg genkey > 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 anpassen, Address einfügen und Abschnitt Peer

[Interface]
ListenPort = <port>
PrivateKey = <private-key>
Address = 10.0.0.1/24

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

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

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

• Konfigurationsdatei anpassen (Address und Abschnitt Peer)

[Interface]
ListenPort = <port>
PrivateKey = <private-key>
Address = 10.0.0.2/24

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

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

• auf dem VPN-Gateway

oot@debian-s-1vcpu-1gb-ams3-01:/etc/wireguard# wg-quick down wg0
[#] ip link delete dev wg0
root@debian-s-1vcpu-1gb-ams3-01:/etc/wireguard# wg-quick up wg0
[#] ip link add wg0 type wireguard
[#] wg setconf wg0 /dev/fd/63
[#] ip link set mtu 1420 up dev wg0
[#] ip route add 10.0.0.1/32 dev wg0

• auf dem VPN-Client

root@router05:/etc/wireguard# wg-quick down wg0
[#] ip link delete dev wg0
root@router05:/etc/wireguard# wg-quick up wg0                                                                   
[#] ip link add wg0 type wireguard
[#] wg setconf wg0 /dev/fd/63
[#] ip link set mtu 1420 up dev wg0
[#] wg set wg0 fwmark 51820
[#] ip -4 route add 0.0.0.0/0 dev wg0 table 51820
[#] ip -4 rule add not fwmark 51820 table 51820
[#] ip -4 rule add table main suppress_prefixlength 0

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

ping 10.0.0.2

• der DNS-Resolver des Linuxhotels ist über den Tunnel nicht erreichbar, 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

• Sichtbare IP-Adresse des Client mit und ohne Wireguard prüfen, z.B. per Firefox auf der Seite https://ripe.net
• Route zu einem Host im Internet per mtr testen, mit und ohne Wireguard
• Wireguard aktivieren, mtr auf einen Server im Internet laufen lassen. Dann von Ethernet (Kabel) auf WLAN umschalten, der mtr Trace darf nicht abbrechen, der Wireguard Tunnel überlebt das umschalten

apt install mtr
mtr -t google.com

• die folgenden Schritte sowohl auf dem VPN-Gateway, als auch auf dem Client ausführen
• manuell gestartetes Wireguard beenden

wg-quick down wg0

• Wireguard per Systemd aktivieren

systemctl enable wg-quick@wg0
systemctl start wg-quick@wg0
systemctl status wg-quick@wg0
● wg-quick@wg0.service - WireGuard via wg-quick(8) for wg0
   Loaded: loaded (/lib/systemd/system/wg-quick@.service; enabled; vendor preset: enabled)
   Active: active (exited) since Mon 2019-05-06 16:18:02 EDT; 1s ago
     Docs: man:wg-quick(8)
	   man:wg(8)
	   https://www.wireguard.com/
	   https://www.wireguard.com/quickstart/
	   https://git.zx2c4.com/WireGuard/about/src/tools/man/wg-quick.8
	   https://git.zx2c4.com/WireGuard/about/src/tools/man/wg.8
  Process: 13492 ExecStart=/usr/bin/wg-quick up wg0 (code=exited, status=0/SUCCESS)
 Main PID: 13492 (code=exited, status=0/SUCCESS)

May 06 16:18:02 router05 systemd[1]: Starting WireGuard via wg-quick(8) for wg0...
May 06 16:18:02 router05 wg-quick[13492]: [#] ip link add wg0 type wireguard
May 06 16:18:02 router05 wg-quick[13492]: [#] wg setconf wg0 /dev/fd/63
May 06 16:18:02 router05 wg-quick[13492]: [#] ip address add 10.0.0.1/24 dev wg0
May 06 16:18:02 router05 wg-quick[13492]: [#] ip link set mtu 1420 up dev wg0
May 06 16:18:02 router05 wg-quick[13492]: [#] wg set wg0 fwmark 51820
May 06 16:18:02 router05 wg-quick[13492]: [#] ip -4 route add 0.0.0.0/0 dev wg0 table 51820
May 06 16:18:02 router05 wg-quick[13492]: [#] ip -4 rule add not fwmark 51820 table 51820
May 06 16:18:02 router05 wg-quick[13492]: [#] ip -4 rule add table main suppress_prefixlength 0
May 06 16:18:02 router05 systemd[1]: Started WireGuard via wg-quick(8) for wg0.

• 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
• PDF-Druck Version für Chrome https://notes.defaultroutes.de/tls.html?print-pdf

• RSA-Privaten Schluessel erstellen (2048 bit)

mkdir ~/tls
cd ~/tls
openssl genrsa -aes128 -out mykey.private 2048
less mykey.private
openssl rsa -text -in mykey.private | less

• öffentlichen RSA-Schlüssel erzeugen

openssl rsa -in mykey.private -pubout -out mykey.public
less mykey.public
openssl rsa -text -pubin -in mykey.public | less

• Certificate signing request (CSR) erstellen

openssl req -new -key mykey.private -out mycert.csr
less mycert.csr
openssl req -text -in mycert.csr -noout | less

• CSR mit Konfigurationsdatei / mehrere Domain-Namen. Hier im Beispiel eine Datei mit dem Namen mycert.conf erstellen:

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

[dn]
CN = ubu01do.strotmann.de
emailAddress = carsten@strotmann.de
O = Linuxhotel
L = Essen
C = DE

[ext]
subjectAltName = DNS:www.ubu01do.strotmann.de,DNS:ubu01do.strotmann.de

• Certificate Signing Request mittels der Konfigurationsdatei erstellen

openssl req -new -config mycert.conf -key mykey.private -out mycert.csr

• Self-Signed-Certificate erstellen (selbst signieren, ohne CA)

openssl x509 -req -days 365 -in mycert.csr -signkey mykey.private -out mycert.crt

• x.509 Cert per OpenSSL anzeigen

openssl x509 -text -in mycert.crt -noout

• Alternatives Kommando zum Erstellen eines Self-Signed Certificate: Self-Signed-Cert ohne CSR (Signing Reuqest Zwischenschritt)

openssl req -new -x509 -config mycert.conf -days 365 -key mykey.private -out mycert.crt

• per OpenSSL eine Verbindung zu einem Server erstellen (https und starttls für smtp, pop3, imap, ftp und xmpp)

openssl s_client -connect www.linuxhotel.de:443
openssl s_client -connect mx.openit.de:25 -starttls smtp
echo "quit" | openssl s_client -connect mx.openit.de:25 -starttls smtp > mx.openit.de.pem
openssl x509 -text -noout -in mx.openit.de.pem | less

• TLS Server mit SNI (Server Name Indication)

openssl s_client -connect www.linuxhotel.de:443 -servername www.linuxhotel.de

• Webseite des Caddy Webserver https://caddyserver.com
• wir arbeiten auf dem Debian VPS im Internet
• NGINX (und andere Server auf Port 80/443) stoppen

systemctl stop nginx

• 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
mv caddy /usr/local/bin

• 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 -conf /srv/Caddyfile

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

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

• SSLLabs Tests: https://www.ssllabs.com/ssltest/
• Starte den Caddy-Server und teste die Domain vm0x.defaultroutes.de

• für die Übung die IPTables Firewall auf dem router ausschalten, Masquerading NAT für die Paketinstallation aber angeschaltet lassen
• in einem separaten Terminal-Fenster auf dem Router ein tcpdump für icmp laufen lassen, um die Kommunikation zwischen Client und Server zu beobachten

router# tcpdump -i enp0s8 icmp

• auf dem Client und auf dem Server

apt install strongswan

• Host-to-Host Tunnel Mode (Client) /etc/ipsec.conf

config setup

conn %default
     ikelifetime=60m
     keylife=20m
     rekeymargin=3m
     keyingtries=1
     keyexchange=ikev2
     authby=secret

conn host-host
     left=172.16.x.2
     right=100.64.x.2
     auto=add

• Passwort (PSK) Client /etc/ipsec.secrets

: PSK 'sharedsecret'

• Host-to-Host Tunnel Mode (Server) /etc/ipsec.conf

config setup

conn %default
     ikelifetime=60m
     keylife=20m
     rekeymargin=3m
     keyingtries=1
     keyexchange=ikev2
     authby=secret

conn host-host
     left=100.64.x.2  # Konfig auf dem Server
     right=172.16.x.2 # Konfig auf dem Server
     auto=add

• Passwort (PSK) Server /etc/ipsec.secrets

: PSK 'sharedsecret'

• IPSec Daemon starten (auf beiden Rechnern Server/Client)

ipsec restart

• Status der Verbindungen abfragen (derzeit ist noch keine Verbindung aktiv)

ipsec status
ipsec statusall

• IPSec Verbindung starten

ipsec up host-host
ipsec status
ipsec statusall

• ein ping zwischen Client und Server VM sollte weiterhin möglich sein, jetzt aber auf dem Router mit tcpdump nicht mehr sichtbar sein
• IPSec Status aus dem Linux-Kernel anzeigen

ip xfrm state

• vom Laptop per SSH X11 Tunnel auf den Router verbinden

ssh -Y nutzer@192.168.1.xxx <-- IP des Routers

• Wireshark installieren und den Benutzer nutzer der Gruppe wireshark hinzufügen, so das der Benutzer das Recht hat, per Sniffing Netzwerkpakete abzuhören

su -
apt install wireshark
usermod -a -G wireshark nutzer
exit

SSH Verbindung beenden, neu einloggen (damit die neue Gruppenzugehörigkeit aktiv wird) und Wireshark starten

router0x$ wireshark

• Im Wireshark auf Interface enp0s8/enp0s9 sniffen
• auf dem Server einen Webserver starten

server0$ python -m SimpleHTTPServer

• auf dem Client die Webseite aufrufen

client0x$ links http://100.64.x.2:8000

• Im Wireshark sollten wir zwischen der Client-IP und Server-IP nur ESP-, aber keine HTTP-Pakete
• IPSec stoppen (ipsec down host-host), dann das Experiment ohne IPSec wiederholen. Es sollten nun die HTTP-Pakete im Wireshark sichtbar sein

• um per IPSec geschützte Daten im Wireshark entschlüsseln zu können, werden für jede Richtung (Security Association) benötigt: Quell-Adresse, Ziel-Adresse, SPI, Verschlüsselungs-Algorithmus, Verschlüsselungs-Schlüssel, Authentisierungs-Algorithmus und Schlüssel für die Authentisierung. Diese Daten werden auf einem Linux-Rechner mit aktiver IPSec Verbindung mit dem Befehl ip xfrm state angezeigt:

root@client05:~# ip xfr state
src 172.16.5.2 dst 100.64.5.2
        proto esp spi 0xc3d57e0e reqid 3 mode tunnel
        replay-window 0 flag af-unspec
        auth-trunc hmac(sha256) 0xebd9e051b05a07c89e51d4840ab2df87d8ca107385cee1bc291d0dd442293dd3 128
        enc cbc(aes) 0xd5719f2b10cd766bb7562099c0ee4bb5
        anti-replay context: seq 0x0, oseq 0x5, bitmap 0x00000000
src 100.64.5.2 dst 172.16.5.2
        proto esp spi 0xcf12dd2b reqid 3 mode tunnel
        replay-window 32 flag af-unspec
        auth-trunc hmac(sha256) 0xc82360181bc299d6931cc8061508740d5d25216f6b31ca93c436b65d27072c2e 128
        enc cbc(aes) 0x4e8a18060003b6727d8f8509e98310c5
        anti-replay context: seq 0x5, oseq 0x0, bitmap 0x0000001f

• Diese Daten im Wireshark unter Edit -> Preferences -> Protocols -> ESP -> ESP SAs -> Edit eintragen. Alle Felder müssen gefüllt werden. Die Schlüssel werden in der Hexadezimalen Schreibweise mit vorangestelltem 0x (wie vom ip xfrm state Befehl ausgegeben) eingetragen.
• Der Packet Trace im Wireshark wird nun dekodiert, die verschlüsselten Protokolle (z.B. HTTP) können analysiert werden.

• auf dem Laptop arbeiten

apt install tor
systemctl enable tor
systemctl start 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

• Webserver Service starten (einfacher Python Webserver auf Port 8000)

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 dem Firefox oder mit dem Tor-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.

• Installation (auf Client und Server)

apt 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

• PGP Schlüssel aus dem DNS Abfragen https://sys4.de/en/blog/2015/03/08/openpgpkey-mit-unix-bordmitteln/

#!/bin/bash
# fetches an OPENPGPKEY and pipes the key into gpg based on a
# Twitter msg by Paul Wouters
# (https://twitter.com/letoams/status/560834359981539329) updated for
# draft-ietf-dane-openpgpkey-03 2015-05-14

maildomain=$(echo $1 | cut -d "@" -f 2)
localmail=$(echo $1 | cut -d "@" -f 1)
openpgpkeydomain=$(echo -n $localmail | openssl dgst -sha256 | cut -d "=" -f 2 | cut -c 1-57)._openpgpkey.$maildomain
echo "fetching ${openpgpkeydomain} ..."
dig +short +vc type61 $openpgpkeydomain | sed "s/ [^ ]*//;s/\W//g" | xxd -r -p | gpg

• OPENPGPKEY manuell abfragen (ab BIND 9.10.0)

dig 3b8b91c75627bee566dcb88f4805901b20a3eab2520bcff8d26c8715._openpgpkey.sys4.de OPENPGPKEY

• OPENPGPKEY manuell abfragen (vor BIND 9.10.0)

dig 3b8b91c75627bee566dcb88f4805901b20a3eab2520bcff8d26c8715._openpgpkey.sys4.de TYPE61

• S/MIME Zertifikate aus dem DNS Abfragen

#!/bin/bash
# fetches an SMIMECERT
# 2016-01-20

maildomain=$(echo $1 | cut -d "@" -f 2)
localmail=$(echo $1 | cut -d "@" -f 1)
smimecertdomain=$(echo -n $localmail | openssl dgst -sha256 | cut -d "=" -f 2 | cut -c 1-57)._smimecert.$maildomain
echo "fetching ${smimecertdomain} ..."
dig +short +vc type53 $smimecertdomain

• SMAUG Plugin für Thunderbird um S/MIME Zertifikate aus dem DNS zu laden https://github.com/verisign/smaug-tbird-plugin

• wir arbeiten auf der Debian VPS
• Unbound und die DNS-Tools installieren

apt install unbound dnsutils

• DNS-Abfrage manuell testen, bei einer bekannt DNSSEC geschützten Domain muss im Header das AD-Flag (Authentic Data) angezeigt werden. Das AD-Flag ist das Signal, das die DNS-Daten DNSSEC abgesichert sind und korrekt überprüft (validiert) wurden:

dig @127.0.0.1 linuxhotel.de a

• die Linux-Resolver Konfiguration anpassen, damit alle Anwendungen des Servers über den Unbound DNS-Resolver gehen

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

• DNSSEC Vertrauenskette mit dem Tool drill aus dem Paket ldnsutils anzeigen

apt install ldnsutils

• den Root-KSK Schlüssel besorgen und lokal abspeichern

dig @a.root-servers.net dnskey . | grep 257 > root.key

• DNSSEC Vertrauenskette prüfen

drill -SD -k root.key www.linuxhotel.de a

• Folien: https://doh.defaultroutes.de/DNS-Sicherheit-Roundtable.html
• PDF-Druck Version für Chrome: https://doh.defaultroutes.de/DNS-Sicherheit-Roundtable.html?print-pdf

• 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

• 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
• Public Key Cryptography — A Comprehensive Guide https://medium.com/blockwhat/public-key-cryptography-a-comprehensive-guide-1e8489e08104