Debian-Linux Server Sicherheit Kursnotizen November 2019

• rngd installieren

apt install rng-tools5
systemctl status rngd

• aus /dev/random lesen und der Durchsatz per pv anzeigen lassen

apt install pv
dd if=/dev/random | pv > /dev/null

• haveged an-/ausschalten (in einem anderen Terminal, die Datenrate im pv betrachten)
• Dasselbe mit rngd
• Beide zusammen und keines von Beiden

systemctl stop haveged rngd
systemctl start rngd
systemctl stop rngd
systemctl start haveged
systemctl start rngd

• Prüfen, ob eine Debian Installations-CD/DVD "original" ist, d.h. vom Debian-Release Team stammt:
• CD-Rom ISO Image laden

wget https://debian.inf.tu-dresden.de/debian-cd/10.1.0/amd64/iso-cd/debian-10.1.0-amd64-netinst.iso

• SHA256 Fingerabdruck der Datei errechnen

openssl dgst -sha256 < debian-10.1.0-amd64-netinst.iso

• Datei mit den Hash-Prüfsummen laden

wget https://debian.inf.tu-dresden.de/debian-cd/10.1.0/amd64/iso-cd/SHA256SUMS

• Hash der ISO-Datei mit dem Hash in der Prüfsummendatei vergleichen
• Nun prüfen wir, ob die Datei mit den Hash-Prüfsummen original ist. Dabei wird die digitale Signatur (mittels GNU-PG) über die Datei mit den SHA256-Hashes geprüft. Wir laden die Signatur der Hash-Prüfsummen vom Download-Server:

wget https://debian.inf.tu-dresden.de/debian-cd/10.1.0/amd64/iso-cd/SHA256SUMS.sign

• Releases der Debian-Distribution werden mit extra Schlüsseln des Debian-Release-Teams signiert. Wenn wir direkt versuchen, die Signatur auf der Datei zu prüfen, so bekommen wir einen Fehler, da wir den öffentlichen Schlüssel (ID DF9B9C49EAA9298432589D76DA87E80D6294BE9B) des Debian-Release-Teams nicht in unserem GPG-Schlüsselbund haben:

debian$ gpg --verify SHA256SUMS.sign SHA256SUMS
gpg: Signature made Sun Sep  8 17:52:41 2019 CEST
gpg:                using RSA key DF9B9C49EAA9298432589D76DA87E80D6294BE9B

gpg: Can't check signature: No public key

• Um die Signaturen prüfen zu können, importieren wir den Debian CD Signatur-Schlüssel in den eigenen GPG-Schlüsselring.

# su -
# apt -y install dirmngr
# exit
# gpg  --keyserver keyring.debian.org --recv-keys DF9B9C49EAA9298432589D76DA87E80D6294BE9B
gpg: key DA87E80D6294BE9B: public key "Debian CD signing key <debian-cd@lists.debian.org>" imported
gpg: Total number processed: 1
gpg:               imported: 1

• Fingerabdruck des Schlüssels anzeigen und mit den Daten auf https://www.debian.org/CD/verify.html abgleichen

gpg --finger  DF9B9C49EAA9298432589D76DA87E80D6294BE9B

• Signature auf der Prüfsummendatei prüfen

# gpg --verify SHA256SUMS.sign SHA256SUMS
gpg: Signature made Sun Sep  8 17:52:41 2019 CEST
gpg:                using RSA key DF9B9C49EAA9298432589D76DA87E80D6294BE9B
gpg: Good signature from "Debian CD signing key <debian-cd@lists.debian.org>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: DF9B 9C49 EAA9 2984 3258  9D76 DA87 E80D 6294 BE9B

• Um dem CD-ROM Image vertrauen zu können, sollten alle Prüfsummen und Signaturen stimmen.

• Die Debian-GPG Schlüssel zum verifizieren von Software-Paketen liegen im Verzeichnis /etc/apt/trusted.gpg.d/

• https://wiki.debian.org/SecureApt
• https://keyring.debian.org/
• https://ftp-master.debian.org/keys.html
• https://launchpad.net/debian/+source/debian-archive-keyring/+changelog
• https://debian-handbook.info/browse/stable/sect.package-authentication.html

• In der Datei /etc/pam.d/common-password wird die Stärke der Benutzer-Passwörter angepasst. Eine Änderung in dieser Datei wirkt sich nur auf alle neu gesetzten Passwörter aus, alle schon vorher vergebenen Passwörter bleiben mit der vorherigen Einstellung bestehen. D.h. nach einer Änderung dieses Parameters sollten wichtige Passwörter neu vergeben werden.

[...]
password    [success=1 default=ignore]    pam_unix.so obscure sha512 rounds=1000000
[...]

• Die Sicherheit der Gruppenpasswörter werden in der Datei /etc/login.defs festgelegt. Wenn Gruppenpasswörter benutzt werden, wird empfolen diese Werte mit der PAM-Konfiguration gleich zu halten.

ENCRYPT_METHOD SHA512
SHA_CRYPT_MIN_ROUNDS 1000000
SHA_CRYPT_MAX_ROUNDS 1000000

• Die Benutzerinformationen für die Passwortanmeldung unter Unix/Linux werden in der Datei /etc/shadow gespeichert

• Installiere das Modul pam_warn.so fuer die Facility auth in PAM-Dienst login
• Schalte auf einen der Konsolen-Bildschirme des Laptops um "STRG+ALT+F2 … F8"
• Melde dort den Benutzer nutzerXX an
• Prüfe die Syslog/Journal Ausgabe

• in Datei /etc/pam.d/login

auth       required   pam_warn.so

• in Datei und /etc/pam.d/common-session

session       required   pam_warn.so

• per STRG+ALT+F2 auf eine Text-Konsole wechseln
• als nutzerXX einloggen
• die neuen Log-Einträgen in /var/log/auth.log prüfen

• Es gibt ein PAM-Modul, welches allen normalen Benutzern die Anmeldung am System verweigert. Nur der root Benutzer darf sich dann anmelden.
• Dieses PAM-Modul ist schon für den Dienst login konfiguriert, aber nicht aktiv (Datei /etc/pam.d/login)
• Lese die Man-Pages der PAM-Module für den Dienst login der auth-Funktionen, finde heraus, welches Modul das Login aller Nicht-Root-Benutzer verweigern kann, und wie es aktiviert wird.
• Aktiviere diese Funktion und teste diese aus. Wechsle mit STRG+ALT+F2 auf die Text-Konsole und versuche Dich dort mit dem normalen Benutzer anzumelden. Alternativ: Anmeldung per SSH über das Loopback-Interface:

ssh nutzerXX@localhost

• Wie kann einem normalen Benutzer der Grund für den Fehlschlag des Anmeldeversuches mitgeteilt werden?

• Modul pam_nologin.so, aktiviert durch die Datei /etc/nologin:

echo 'Heute kein Login möglich! Wartungsarbeiten bis Dienstag!' > /etc/nologin

• RFC 4226 HOTP: An HMAC-Based One-Time Password Algorithm (https://tools.ietf.org/html/rfc4226)
• Alternative: RFC 6238 "TOTP: Time-Based One-Time Password Algorithm"
• Token-Software als App für viele Mobiltelefone verfügbar
• Pakete installieren

apt install libpam-oath oathtool

• pam_oath in die PAM Konfiguration aufnehmen (hier für den su Befehl). window=5 gibt ein Fenster von 5 Passwörtern aus der Liste an, welche akzeptiert werden.

$EDITOR /etc/pam.d/su
-----
#%PAM-1.0
auth            sufficient      pam_rootok.so
auth            requisite       pam_oath.so usersfile=/etc/oath/users.oath window=5
-----

• OATH Benutzerdatei anlegen

mkdir /etc/oath
$EDITOR /etc/oath/users.oath
-----
HOTP nutzerXX - <hex-secret>
HOTP nutzerYY - 0102030405

• Beispiel: Passwort in HEX-Zahl umrechnen:

echo "villa" | od -x
0000000 6976 6c6c 0a61
0000006

• Benutzerrechte setzen

chmod 000 /etc/oath/users.oath
chown root: /etc/oath/users.oath

• Eine Reihe (5 Stück) von Passwörter zum Test erstellen

oathtool -w 5 <hex-secret>

• Anmeldung ausprobieren als "nutzerXX", eines der Passwörter aus der Liste probieren

su - nutzerXX

• Wer ein Smart-Phone hat, mal im App-Store nach "OATH" suchen, eines OATH-Token Programm installieren und konfigurieren

• OTPW = One-Time-Password – ähnlich einer TAN-Liste
• OTPW Pakete installieren

apt install libpam-otpw otpw-bin

• das Modul pam_otpw in die PAM-Konfiguration vom su aufnehmen, die Konfiguration von OATH und common-auth auskommentieren

...
auth            required        pam_otpw.so
...
session         optional        pam_otpw.so
#@include common-auth
...

• Das Programm otpw-gen benutzt die Ausgabe von netstat, um den eigenen Zufallszahlengenerator zu initialisieren (ist das sicher?). netstat ist jedoch auf modernen Linux-Systemen wie Debian 9 nicht vorhanden und muss manuell installiert werden:

apt install net-tools

• Als Benutzer nutzerXX eine Passwortliste erstellen (dabei das Prefix-Passwort angeben) und ggf. ausdrucken. Ausdrucke finden sich im Kyocera-Drucker in der Vorhalle

su - nutzerXX
otpw-gen > otpwlist.txt
less otpwlist.txt
lp otpwlist.txt

• OTPW legt Hashes der Einmalpasswörter in der Datei ~/.otpw ab

less ~/.otpw

• OTPW ausprobieren (als NutzerXX nochmals per su anmelden). Das bei der Erstellung der Passwort-Liste angegebene Passwort muss vor dem Einmal-Passwort eingegeben werden

su - nutzerXX

• das Passwort ist nun verbraucht und aus der Liste gestrichen

less ~/.otpw

• Befehl cat auf die Datei /var/log/apt/term.log für Benutzer nutzer02

vi /etc/sudoers.d/apt-term-cat
----
nutzer02 ALL=(root) /bin/cat /var/log/apt/term.log
----
nutzerXX$ sudo -l

• sudo -l Zeigt die sudo-Konfiguration und die erlaubten Befehle eines sudo-Benutzers an.

• Erstelle eine sudo Konfiguration, um es dem Benutzer nutzerXX zu erlauben, die Logdateien /var/log/messages und /var/log/daemon.log unter den Benutzerberechtigungen des Benutzers root mit den Programmen more und less anzuschauen

vi /etc/sudoers.d/log-message-view
------
...
nutzerXX  ALL=(root) /usr/bin/more /var/log/messages
nutzerXX  ALL=(root) /usr/bin/more /var/log/daemon.log
nutzerXX  ALL=(root) /usr/bin/less /var/log/messages
nutzerXX  ALL=(root) /usr/bin/less /var/log/daemon.log
...

• in einem anderen Terminal/Tmux-Fenster, teste sudo als nutzerXX

nutzerXX$ sudo more /var/log/messages
nutzerXX$ sudo less /var/log/daemon.log
nutzerXX$ sudo less /etc/shadow       # <--- darf nicht gehen
nutzerXX$ sudo more /var/log/auth.log # <--- darf nicht gehen

• gibt es mit dieser Konfiguration ein Sicherheitsproblem?

• Ja - less und viele andere Programme können Unterprogramme aufrufen (z.B. eine Shell), welche dann mit root-Rechten läuft
• Lösung: NOEXEC:

nutzerXX  ALL=(root) NOEXEC: /usr/bin/more /var/log/messages
nutzerXX  ALL=(root) NOEXEC: /usr/bin/more /var/log/boot.log

     # User alias specification
     User_Alias      FULLTIMERS = millert, mikef, dowdy
     User_Alias      PARTTIMERS = bostley, jwfox, crawl
     User_Alias      WEBMASTERS = will, wendy, wim

     # Runas alias specification
     Runas_Alias     OP = root, operator
     Runas_Alias     DB = oracle, sybase
     Runas_Alias     ADMINGRP = adm, oper

     # Host alias specification
     Host_Alias      SPARC = bigtime, eclipse, moet, anchor :\
                     LINUX = grolsch, dandelion, black :\
                     LINUX_ARM = widget, thalamus, foobar :\
                     LINUX_PPC64 = boa, nag, python
     Host_Alias      CUNETS = 128.138.0.0/255.255.0.0
     Host_Alias      CSNETS = 128.138.243.0, 128.138.204.0/24, 128.138.242.0
     Host_Alias      SERVERS = master, mail, www, ns
     Host_Alias      CDROM = orion, perseus, hercules

     # Cmnd alias specification
     Cmnd_Alias      KILL = /usr/bin/kill, /usr/bin/pkill
     Cmnd_Alias      PRINTING = /usr/sbin/lpc, /usr/bin/lprm
     Cmnd_Alias      SHUTDOWN = /usr/sbin/shutdown
     Cmnd_Alias      HALT = /usr/sbin/halt
     Cmnd_Alias      REBOOT = /usr/sbin/reboot
     Cmnd_Alias      SHELLS = /usr/bin/sh, /usr/bin/zsh, /bin/bash

FULLTIMERS  SPARC=(OP) KILL
WEBMASTERS  LINUX=(:ADMINGRP) SHELLS

• Benutzer nutzerXX soll die Datei /etc/rsyslog.conf editieren dürfen
• in der Datei /etc/sudoers

visudo
----
nutzerXX ALL= sudoedit /etc/rsyslog.conf
----
sudoedit /etc/rsyslog.conf

• Füge die folgenden Konfigurationszeilen in die /etc/sudoers Datei ein

Defaults log_output
Defaults!/usr/bin/sudoreplay !log_output
Defaults!/sbin/reboot !log_output

• nutzerXX darf root werden

nutzerXX ALL=(root) ALL

• Benutze sudo als nutzerXX um eine interaktive Shell zu bekommen

nutzerXX$ sudo -s

• ein paar Befehle ausführen, die Ausgaben produzieren
• die sudo Root-Shell wieder verlassen
• (im Terminal als Benutzer root) Aufgezeichnete Sitzungen auflisten

sudoreplay -l

• aufgezeichnete sudo Sitzung abspielen

sudoreplay <TSID>

• Verzeichnis der sudo Aufzeichnungen:

ls -l /var/log/sudo-io/

openssl dgst -sha256 /usr/bin/passwd
SHA256(/usr/bin/passwd)= a92b1b6fb52549ed23b12b32356c6a424d77bcf21bfcfbd32d48e12615785270
visudo
----
nutzerXX ALL= sha256:a92b1b6fb52... /usr/bin/passwd
----

Defaults passwd_tries=5, passwd_timeout=2
Defaults timestamp_timeout=0 # Disable password caching
Defaults timestamp_timeout=5 # 5 Minuten password caching (default)

nutzer ALL=(dba) NOPASSWD: /opt/oracle/bin/befehl

Defaults targetpw

• Nicht alle Dateisysteme unterstützen alle erweiterten Attribute (EA). Unter Linux unterstützen die ext2/ext3/ext4-Dateisysteme und das XFS-Dateisystem einige der EAs. Die Man-Page zum Dateisystemformat gibt Auskunft über die EA Unterstützung (z.B. man ext4).
• Anzeigen der erweiterten Attribute: lsattr
• Ändern der erweiterten Attribute: chattr
• Sicherheit von erweiterten Attribute (EA) unter Linux im Vergleich zu BSD: unter BSD können die Sicherheitsrelevanten EA (append, immutable) vom Benutzer root nur im Single-User Module (ohne Netzwerk) gelöscht werden. Unter Linux kann root die EA zu jedem Zeitpunkt entfernen!

Als User

cat /usr/bin/ping > PING
chmod a+x PING
./PING 9.9.9.9
sudo -i
setcap cap_net_raw+p .../PING
^d
PING 9.9.9.9

Mit pstree und unter dem proc Dateisystem CapPrm prüfen

capsh --drop=cap_chown --
chown fritz /home/prj

• wir möchten die Capabilities CAP_CHOWN (den Besitzer einer Datei/Verzeichnis ändern) und CAP_DAC_OVERRIDE (Dateiberechtigungen ignorieren) an einen normalen Benutzer delegieren
• PAM Konfiguration prüfen

$EDITOR /etc/pam.d/common-auth
----
[...]
auth        optional      pam_cap.so
[...]

• Die Capability Benutzerkonfiguration erstellen. der Befehl man capabilities listed die Namen und Beschreibungen der verfügbaren Capabilities.

$EDITOR /etc/security/capability.conf
----
cap_chown,cap_dac_override          nutzerXX
----

• Welche Capabilities hat das chown Programm? (sollte derzeit keine haben)

getcap $(which chown)

• Wir setzen die cap_chown Capability auf dem chown Programm

setcap cap_chown=ei $(which chown)
getcap $(which chown)
/bin/chown = cap_chown+ei

• neu als Benutzer nutzerXX anmelden

su - nutzerXX
su - nutzerXX

• nun sollte der aktuelle Prozess die Capability cap_chown besitzen

/sbin/getpcaps $$
Capabilities for `15412': = cap_chown+i

• nun kann der Benutzer nutzerXX Rechte auf Dateien ändern, die ihm nicht gehören:

ls -ld /root
chown nutzerXX /root

• Für alle Benutzer unabhängig von der PAM-Konfiguration

setcap cap_chown=pe $(which chown)

• Konfigurationsdatei der PAM-Limits ist /etc/security/limits.conf. Liste der Resourcen die kontrolliert werden können:

  core	Grösse einer Core-Dump Datei (KB)
  data	maximale Grösse des zu ladenen Programms (KB)
  fsize	maximale Dateigrösse (KB)
  memlock	maximale Grösse des Prozesspeichers, welcher nicht ausgelagert werden darf (KB)
  nofile	maximale Anzahl der offenen Dateien
  rss	maximale Grösse des "resident set size" (Speicherverbrauch eines Prozesses im Hauptspeicher) (KB)
  stack	maximale Grösse des Stacks eines Prozesses (KB)
  cpu	maximale CPU Zeit (MIN)
  nproc	maximale Anzahl von Prozessen
  as	Limit des Addressbereiches (KB)
  maxlogins	maximale Anzahl der Logins pro Benutzername
  maxsyslogins	maximale Anzahl der Logins am System (aller Benutzer)
  priority	Priorität von Benutzerprozessen
  locks	maximale Anzahl von Datei-Locks
  sigpending	maximale Anzahl von wartenden Signalen für Prozesse
  msgqueue	maximaler Speicherverbrauch von POSIX message queues (bytes)
  nice	maximaler "nice" Wert: [-20, 19]
  rtprio	maximale Echtzeit Priorität von Prozessen
  chroot	Benutzer darf den "chroot" Syscall ausführen (Debian spezifisch)

apt install cpulimit
stress -c 8 # CPU Kerne * 2
renice -n <nice-wert> <pid>
cpulimit -l 50 -p <pidid> # nicht mehr empfohlen

systemd-run stress -c 3
systemd-run stress -c 3
systemctl show run-r<UUID>.service
systemctl set-property run-r<UUID>.service CPUShares=100
systemctl set-property run-r<UUID>.service CPUQuota=100

• Units unter anderer uid/gid laufen lassen
• Zugriff auf Verzeichnisse beschränken
• Prozesslimits setzen

$EDITOR /etc/systemd/system/simplehttp.service

[Unit]
Description=HTTP Server

[Service]
Type=simple
Restart=on-failure

#User=karl
#Group=users

#WorkingDirectory=/usr/share/doc
#PrivateTmp=yes
#ReadOnlyDirectories=/var
#InaccessibleDirectories=/home /usr/share/doc
#LimitNPROC=1  #darf nicht forken
#LimitFSIZE=0  #darf keine Files schreiben

ExecStart=/bin/python -m SimpleHTTPServer 8000

• PrivateNetwork=yes
• CapabilityBoundingSet=CAP_CHOWN CAP_KILL
• CapabilityBoundingSet=~CAP_SYS_PTRACE
• DeviceAllow=/dev/null rw

ssh-keygen -H -f .ssh/known_hosts

$EDITOR .ssh/config
----------
HashKnownHosts yes
----------
chmod -Rc go= .ssh

ssh-keygen -p -f .ssh/id_ed25519.pub

Die Benutzung von Passwörter für die SSH-Authentisierung ist einfach aber liefert nur eine minimale Sicherheit. Passwörter sind oft zu erraten oder per Brute-Force-Angriff ermittelbar. Besser sind kryptografische Schlüssel. SSH bietet die Authentisierung per Schlüssel, jedoch wird die Passwort-Anmeldung als Rückfall-Mechanismus benutzt. Um SSH richtig abzusichern sollte daher die Passwort-Anmeldung in der Konfiguration des SSH-Servers abgeschaltet werden.

$EDITOR /etc/ssh/sshd_config
----
PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
----

• in dieser Übung arbeiten wir als Benutzer und als Administrator. Lege mit dem Übungs-Partner die Rolle fest (Benutzer oder Administrator) und führe die Übung durch. Danach wechselt die Rolle.
• Administrator: lege einen Benutzeraccount für den Kollegen/Kollegin vor/hinter Dir im Kurs an (Passwort und Benutzername absprechen)
• Administrator: OpenSSH Server installieren (wenn nicht schon geschehen)

sudo apt install openssh-server

• Benutzer: Teste aus, dass Du Dich auf dem System des Übungs-Partners einloggen kannst. Bei der ersten Kontaktaufnahme wird der Fingerprint des Servers angezeigt. Dieser Fingerprint kann über den Administrator des Servers angefragt werden.

nutzerXX: ssh nutzerXX@notebookYY

• Benutzer: nach dem Test wieder aus dem fernen Rechner ausloggen
• Benutzer: als normaler Benutzer (nutzerXX, nicht root) einen neuen SSH-Schlüssel erstellen (4096 RSA). Eine Passphrase vergeben.

nutzerXX$ ssh-keygen -b 4096

• Benutzer: den öffentlichen Schlüssel per SSH auf den fernen Rechner übertragen:

nutzerXX$ ssh-copy-id nutzerXX@notebookYY

• Benutzer: Alternativ die Datei ~/.ssh/id_rsa.pub vom eigenen Rechner auf den fernen Rechner übertragen (z.B. per E-Mail senden) und den Administrator bitten, den eigenen Schlüssel in die Datei .ssh/authoritzed_keys einzutragen.
• Administrator: Nun sind die Schlüssel ausgetauscht, und wir können Anmeldung per Passwort auf dem Server-System abschalten. Als root Benutzer:

$EDITOR /etc/ssh/sshd_config
------
PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
------

• Administrator: SSH-Dienst neu starten

systemctl restart sshd

• Benutzer: Anmeldung am fernen Rechner testen, dies sollte nun nach Eingabe der Passphrase funktionieren

nutzerXX$ ssh nutzerXX@notebookYY

• Benutzer: Wenn ein Benutzer ohne Schlüssel versucht, sich am fernen Rechner anzumelden, wird er gleich abgewiesen

ssh root@notebookYY

• Info Benutzer: die Fingerprints der Server werden beim Client unter ~/.ssh/known_hosts gespeichert
• Info Administrator: die öffentlichen Schlüssel werden auf dem fernen Rechner in der Datei ~/.ssh/authorized_keys gespeichert

• SSH-Agent starten (wird normalerweise in der Benutzer-Sitzung gestartet, z.B. über ".profile")

eval $(ssh-agent)

• die privaten SSH-Schlüssel dem SSH-Agent hinzufügen

ssh-add
ssh-add <schlüssel>

• Fingerprints aller Schlüssel im Agent anzeigen

ssh-add -l

• alle Schlüssel im Agent anzeigen

ssh-add -L

• Agent sperren/entsperren

ssh-add -x
ssh-add -X

• Schlüssel im SSH-Agent löschen

ssh-agent -D

• SSH Fingerprint eines Schlüssels auf einem Server anzeigen (zur Prüfung eines ersten Logins)

ssh-keygen -l -f /etc/ssh/ssh_host_<algorithm>_key.pub

• Bei komplexen SSH-Konfigurationen ist es hilfreich, die SSH-Parameter pro Ziel-System in der lokalen SSH-Konfigurationsdatei für den Benutzer abzulegen. Fast alle Kommandozeilen-Optionen des SSH-Clients können in dieser Konfigurationsdatei festgelegt werden (siehe man ssh).
• Beispiel einer lokalen SSH-Konfigurationsdatei für einen Benutzer. Datei ~/.ssh/config

Host zielhost                                          # symbolischer Name
        Hostname zielhost.example.com                  # echter DNS-Name
	User nutzerXX                                  # Standard Benutzer
	Compression yes                                # gzip Kompression an
	VerifyHostKeyDNS yes                           # Host-Key per DNS prüfen
	Port 65123                                     # SSH läuft auf diesem Port
	ProxyJump jumphost.example.com                 # Verbindung über Jumphost

• Agent-Funktion an einem Jumphost weitergeben. Nun kann sich der Benutzer vom Jumphost mit Schlüssel an weiteren SSH-Servern anmelden

ssh -A <jumphost>

• Sicherheits-Probleme mit Agent-Forwarding!
• https://heipei.github.io/2015/02/26/SSH-Agent-Forwarding-considered-harmful/
• https://michael.stapelberg.de/Artikel/ssh-conditional-tunneling
• Agent forwarding (ssh -A nutzerXX@notebookYY) kann von einem Angreifer auf dem "Jumphost" abgefangen werden (Socket zum Agent im /tmp-Verzeichnis des Jumphost).

• der Konfigurationsparameter VisualHostKey in der Datei /.ssh/config zeigt eine visuelle Darstellung des Schlüssel-Hash jedes Ziel- und Jump-Host Servers an

VisualHostKey yes

• pam_ssh.so – per SSH Key Passphrase anmelden und Schlüssel in den Agent laden
• pam_sshauth.so – lokale Anmeldung durch erfolgreiche SSH-Anmeldung an einen fernen SSH Server

• Über SSH Tunnel können beliebige Ports über die SSH Verbindung geleitet werden
• Tunnel von Port 80 auf dem Server zu Port 8080 auf dem Client

ssh -L 8080:notebookXX:80 nutzerXX@notebookXX
ssh -L 8080:datenbank:80 nutzerXX@notebookXX

• Rückwärts-Tunnel: vom Ziel-System zurück auf den Client. Dieses Beispiel öffnet einen Tunnel von localhost:8000 auf dem Zielsystem auf Port 8000 des SSH-Clients

ssh -R 8000:notebookXX:8000 nutzerXX@notebookXX

• Socks-Proxy Forwarding (Web-Browsen durch den Tunnel), im Browser die Socks-Proxy Konfiguration auf 127.0.0.1 Port 8080 setzen

ssh -CD 127.0.0.1:8080 nutzer@server

• Socks-Proxy Forwarding (Web-Browsen durch den Tunnel), im Browser die Socks-Proxy Konfiguration auf 127.0.0.1 Port 8080 setzen
  • Option -C schaltet Kompression der Daten im Tunnel ein
  • Option -D schaltet den Socks-Proxy für den SSH-Tunnel ein

ssh -C -D 127.0.0.1:8080 nutzer@server

• A tilde (~) after an Enter is the escape sequence of SSH
• ~~ Tilde senden
• ~. SSH-Verbindung sofort stoppen
• ~<Ctrl-Z> SSH Sitzung in den Hintergrund senden (mit fg wieder in den Vordergrund holen)
• ~& SSH als 'daemon' in den Hintergrund senden und vom Terminal ablösen
• ~? Hilfe anzeigen.
• ~R neuen Sitzungschlüssel aushandeln
• ~C SSH Komandozeile anzeigen (kann benutzt werden um neue Tunnel in schon bestehende Verbindungen einzubauen)
• ~# bestehende SSH-Tunnel anzeigen

• SSH Fingerprint im DNS hinterlegen (DNSSEC Absicherung empohlen!). SSHFP Records erstellen (auf dem Server, je ein Aufruf pro Schlüssel-Type (RSA, ECDSA, ED25519 …):

ssh-keygen -r <hostname> -f /etc/ssh/ssh_host_<algorithm>_key.pub

• SSH mit Prüfung des SSH-Fingerabdrucks in DNS

ssh -o "VerifyHostKeyDNS ask" <hostname>

• in SSH-Config Datei übernehmen

$EDITOR ~/.ssh/config
----
HOST *
  VerifyHostKeyDNS ask

• Test

ssh host.example.com
The authenticity of host 'host.example.com (2001:db8:2b6:0:ba27:ebff:fe12:30db)' can't be established.
ECDSA key fingerprint is SHA256:ue1FlRUMmkPNhgFE55yqnnFl58FOlMnDGheCxQn2tWg.
Matching host key fingerprint found in DNS.
ECDSA key fingerprint is MD5:2e:a1:3c:94:d0:cb:ed:85:67:2e:7a:85:1c:bc:f3:70.
Matching host key fingerprint found in DNS.
Are you sure you want to continue connecting (yes/no)?

• mit VerifyHostKeyDNS yes

ssh -v <host>
[...]
debug1: found 4 secure fingerprints in DNS
debug1: matching host key fingerprint found in DNS
[...]

• Wenn OpenSSH Probleme hat, die DNSSEC Authentizität der SSHFP zu prüfen, muss ggf. EDNS in der Resolver-Konfiguration des Linux eingeschaltet werden

$EDITOR /etc/resolv.conf
----
[...]
options edns0

command="foobar" ssh-rsa AAAAB3Nza… calls "foobar" and only "foobar" upon every login with this key
from="computer" ssh-rsa AAAAB3Nza… allows access with this key only from the host "computer".

• Authorized-Keys via FUSE und DNS http://jpmens.net/2012/12/18/ssh-public-keys-on-a-dns-fuse/
• Authorized-Keys per TXT-Record im DNS (ohne FUSE) https://blog.cloudflare.com/flexible-secure-ssh-with-dnssec/

https://blog.habets.se/2013/11/TPM-chip-protecting-SSH-keys---properly.html https://github.com/ThomasHabets/simple-tpm-pk11

• Original von Jan-Piet Mens mit Benachrichtigung via MQTT: https://jpmens.net/2018/03/25/alerting-on-ssh-logins/
• zentralisierte Benachrichtigung bei SSH-Logins auf einem Rechner der eigenen IT-Infrastruktur. Kommunikation zwischen SSH-Server und zentraler Monitoring-Instatnz über leichtgewichtiges UDP, E-Mail Kommunikationsparameter werden zentral verwaltet.
• Quellcode des hare Programms (PAM-Modul für die SSH-Server)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <memory.h>
#include <sys/socket.h>

/*
 * hare.c (C)2018 by Jan-Piet Mens <jp@mens.de>
 */

#define PORTNO  8035

#define env(K)  ( getenv(K) ? getenv(K) : "<unknown>" )

int main(int argc, char **argv)
{
        struct sockaddr_in servaddr;
        unsigned long addr;
        int sockfd;
        char *host = argv[1], buf[BUFSIZ], myhostname[BUFSIZ];
        char *pamtype = env("PAM_TYPE");        /* Linux */
        char *pamsm = env("PAM_SM_FUNC");       /* FreeBSD https://www.freebsd.org/cgi/man.cgi?query=pam_exec */

        if (strcmp(pamtype, "open_session") != 0 && strcmp(pamsm, "pam_sm_open_session") != 0) {
                fprintf(stderr, "Neither PAM open_session nor pam_sm_open_session detected\n");
                return 0;
        }

        if (argc != 2) {
                fprintf(stderr, "Usage: %s address\n", *argv);
                exit(2);
        }

        if (gethostname(myhostname, sizeof(myhostname)) != 0)
                strcpy(myhostname, "?");

        snprintf(buf, sizeof(buf), "%s login to %s from %s via %s",
                env("PAM_USER"),
                myhostname,
                env("PAM_RHOST"),
                env("PAM_SERVICE"));

        addr = inet_addr(host);

        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(PORTNO);
        memcpy((void *)&servaddr.sin_addr, (void *)&addr, sizeof(addr));

        sockfd = socket(AF_INET, SOCK_DGRAM, 0);

        if (sendto(sockfd, (void *)buf, strlen(buf), 0, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) {
                perror("sendto");
        }
        return (0);
}

• Übersetzen und Installieren des hare Programms (ggf. das Paket gcc installieren)

gcc -O2 -o hare hare.c
sudo cp hare /usr/local/sbin

• das hare Programm in die PAM-Konfiguration /etc/pam.d/sshd eintragen. Ziel-IP ist der Laptop des Trainers (192.168.1.241)

[...]
session    optional     pam_exec.so /usr/local/sbin/hare <ip-des-hare-servers>
[...]

• der zentrale Python-Server /usr/local/bin/hared.py, mit der Funktion pro SSH-Login eine Benachrichtigungs-Mail zu versenden (läuft auf dem Laptop des Trainers)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import socket
import json
import smtplib, ssl
import random
import string
import datetime

__author__    = 'Jan-Piet Mens <jp()mens.de> / Carsten Strotmann <carsten()strotmann.de>'

myhostname     = "debian.example.com" # Domain-Name des E-Mail Senders (diese Maschine)
smtp_server    = "mail.example.com" # Name of the Mail-Server
smtp_port      = "587"  # SMTP with STARTTLS
sender_email   = "servernotification@example.com"
receiver_email = "admin@example.com"
smtp_user      = "admin"
smtp_password  = "secret"

server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.bind(('', 8035))

while True:
    message, address = server_socket.recvfrom(1024)
    host, port = address

    data = {
        'host' : host,
        'msg'  : message,
    }

    js = json.dumps(str(data))
    # print(js)


    message = "To: <{}>\n".format(receiver_email)
    message = message + "From: <{}>\n".format(sender_email)
    message = message + "Message-Id: <{}@example.com>\n".format(''.join(random.choices(string.ascii_uppercase + string.digits, k=10)))
    time = datetime.datetime.now()
    message = message + "Date: {} \n".format(time.strftime('%d %b %Y  %H:%M:%S %z'))
    message = message + "Subject: SSH Login to {}\n\n".format(data["host"])
    message = message + "SSH Login into {} detected, Message: {}".format(data["host"], data["msg"])

    # Create a secure SSL context
    context = ssl.create_default_context()
    # if the TLS certificate of the mail server does not match
    # the mail servers hostname or domain-name, disable hostname checking
    # context.check_hostname = False
    server = smtplib.SMTP()
    # Try to log in to server and send email
    try:
        server.connect(smtp_server,smtp_port)      # Connect to the server
        server.ehlo(myhostname)                    # Send EHLO
        server.starttls(context=context)           # TLS Secure the connection
        server.ehlo(myhostname)                    # Another EHLO, now TLS secured
        server.login(smtp_user, smtp_password)     # Login to the server

        server.sendmail(sender_email, receiver_email, message) # send the mail
    except Exception as e:
        # Print any error messages to stdout
        print("Error: ", e)
    finally:
        if (server):
            server.quit()

• Quellen
  • SSH Security https://stribika.github.io/2015/01/04/secure-secure-shell.html
  • Secure Secure Shell Wiki: https://github.com/stribika/stribika.github.io/wiki/Secure-Secure-Shell
• SSH Server Konfiguration öffnen

$EDITOR /etc/ssh/sshd_config

• Nur Protokoll Version 2 erlauben

Protocol 2

• Sichere Schlüssel-Austausch-Verfahren

KexAlgorithms curve25519-sha256@libssh.org,diffie-hellman-group-exchange-sha256

• neue DH Moduli für "diffie-hellman-group-exchange-sha256" (Achtung, dauert lange!) Hintergründe unter http://weakdh.org

ssh-keygen -G /etc/ssh/moduli.all -b 4096
ssh-keygen -T /etc/ssh/moduli.safe -f /etc/ssh/moduli.all
mv /etc/ssh/moduli.safe /etc/ssh/moduli
rm /etc/ssh/moduli.all
chcon -v --type=etc_t /etc/ssh/moduli

• EC-ED25519-Kurve Schlüssel bevorzugen

HostKey /etc/ssh/ssh_host_ed25519_key
HostKey /etc/ssh/ssh_host_rsa_key

• Sichere symmetrische Verschlüsselungs-Algorithmen

Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com,aes256-ctr,aes192-ctr,aes128-ctr

• Sichere Message-Authenication-Codes (MAC)

MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512,hmac-sha2-256,umac-128@openssh.com

• Host-Keys neu erzeugen (Achtung: Clients werden Warnungen bekommen, Kunden und Kollegen informieren!)

cd /etc/ssh
rm ssh_host_*key*
ssh-keygen -t ed25519 -f ssh_host_ed25519_key < /dev/null
ssh-keygen -t rsa -b 4096 -f ssh_host_rsa_key < /dev/null

• SSH Server neu starten

systemctl restart sshd

• SSH Client Parameter testen

ssh -Q cipher
ssh -Q cipher-auth
ssh -Q mac
ssh -Q kex
ssh -Q key

• Jetzt nochmal per SSH auf dem fernen Rechner einloggen, -v Zeigt die Kommunikationsparameter an

nutzerXX$ ssh -v nutzer@notebookYY

• Hier sollte jetzt eine Warnung ausgegeben worden sein, da die Host-Schlüssel nicht mehr mit den Fingerprints in der known_hosts Datei übereinstimmen. Den Admin des fernen Servers fragen, ob er die Schlüssel auf dem Rechner neu erstellt hat. Wenn der Admin dies bestätigt, dann er Texteditor den alten Fingerprint aus der ~/.ssh/known_hosts Datei löschen.
• SSH Client ~/.ssh/config

VerifyHostKeyDNS yes
VisualHostKey yes

Der Linux-Kernel bietet einige Sicherheitfunktionen, welche zur Zeit der Übersetzung des Kernels aus den Quellen angeschaltet werden können. Einige dieser Funktionen haben negative Auswirkungen auf die Ausführungsgeschwindigkeit des Systems, so das diese Funktionen nicht in allen Distributionen gesetzt sind. In den Klammern sind die jeweiligen Konfigurationsnamen aufgeführt. In einem Linux-System können diese Namen in der Kernel-Konfigurationsdatei geprüft werden. Beispiel:

zcat /proc/config.gz | grep CONFIG_SECURITY_DMESG_RESTRICT

oder, wenn /proc/config.gz nicht vorhanden.

cat  /boot/config-$(uname -r) | grep CONFIG_SECURITY_DMESG_RESTRICT

• RELRO - RELocation Read-Only
• PIE - Position Independent Executable
• ASLR - Address Space Layout Randomization
• Fortify Source - Array Bounds-Checks etc.
• Stack protector/StackCanary - Stack Canary
• NX-No-Execute - Daten im Speicher als nicht ausführbar (NX=no execute) markieren

• Hintergrund-Informationen zu diesen Sicherheitsfunktionen: Notes on Build Hardening (December 15, 2018) https://blog.erratasec.com/2018/12/notes-on-build-hardening.html
• Studie von Sicherheitsfunktionen in Linux-Distributionen: Millions of Binaries Later: a Look Into Linux Hardening in the Wild (February 28, 2019) https://capsule8.com/blog/millions-of-binaries-later-a-look-into-linux-hardening-in-the-wild/

• die letzten Logins auf dem System anzeigen

aulast

• Wann haben sich Benutzer zum letzten Mal eingelogged?

aulastlog

• Zusammenfassung des Audit-Log

aureport

• grafische Auswertung von Audit-Logs

$ sudo apt install graphviz gnuplot git
$ git clone https://github.com/cstrotm/audit-visualize
$ cd audit-visualize
$ chmod +x ./mkgraph
$ chmod +x ./mkbar

• grafische Reports erstellen

$ sudo aureport -s -i --summary  | bash ./mkbar syscall
$ sudo aureport -f -i --summary --failed | bash ./mkbar failed-access
$ sudo aureport -e -i --summary | egrep -vi '(syscall|change)'
$ sudo aureport -e -i --summary | egrep -vi '(syscall|change)' | bash ./mkbar events2

• Syscall Benutzung von Programmen

$ sudo aureport -s -i | awk '/^[0-9]/ { printf "%s %s\n", $6, $4 }' | sort | uniq | bash ./mkgraph
Gzipping graph...
Graph was written to gr.png

• welcher Benutzer führt welche Programme aus?

sudo aureport -u -i | awk '/^[0-9]/ { printf "%s %s\n", $4, $7 }' | sort | uniq | bash ./mkgraph

• wer greift auf welche Dateien zu?

sudo aureport -f -i | awk '/^[0-9]/ { printf "%s %s\n", $8, $4 }' | sort | uniq | bash ./mkgraph

• Webseite: https://www.cisecurity.org/cis-benchmarks/

• mit diesem kleinen Beispielprogramm wird gezeigt, das Linux-Container mit nur einem Systemaufruf erzeugt werden.
• Quelle: https://blog.lizzie.io/linux-containers-in-500-loc.html
• C-Compiler und Entwicklungs-Tools installieren

apt install build-essential

• Unser Ausgangs-C-Programm: Leeres Verzeichnis anlegen und die leere Quelltextdatei im Editor öffnen

cd /usr/src
mkdir namespaces
cd namespaces
$EDITOR namespaces.c
----
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <sched.h>
#include <signal.h>
#include <unistd.h>

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];
char* const child_args[] = {
  "/bin/bash",
  NULL
};

int child_main(void* arg)
{
  printf("Namespace aktiv\n");
  execv(child_args[0], child_args);
  printf("Ooops\n");
  return 1;
}

int main()
{
  printf("Namespace wird erzeugt\n");
  int child_pid = clone(child_main, child_stack+STACK_SIZE, \
   CLONE_NEWUTS | CLONE_NEWIPC | SIGCHLD, NULL);
  waitpid(child_pid, NULL, 0);
  printf("Namespace beendet\n");
  return 0;
}

----

• Programm übersetzen

gcc -o namespaces namespaces.c

• Programm ausführen

./namespaces

• den Namespace mit exit verlassen, dann einen Process-Namespace zum Programm hinzufügen

...
 int child_pid = clone(child_main, child_stack+STACK_SIZE, \
   CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWPID | SIGCHLD, NULL);
...

• neu übersetzen und ausführen

gcc -o namespaces namespaces.c

• Einen Netzwerk-Namespace hinzufügen

...
  int child_pid = clone(child_main, child_stack+STACK_SIZE, \
   CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWPID |  CLONE_NEWNET | SIGCHLD, NULL);
...

• Docker bietet gegenüber dem Betrieb von klassischen Linux-Installationen (auf „bare Metal“ oder virtualisiert) einige Vorteile:
  • Anwendungen werden voneinander isoliert. Selbst die Bestandteile einer Anwendung (z.B. LAMP - Linux/Apache/MySQL/PHP) können in eigene Docker-Container ausgelagert und voneinander isoliert werden.
  • die Rechte einer Anwendung im Docker-Conatiner kann per Seccomp-bpf und Linux-Capabilities beschränkt werden
  • die Sicht auf den Netzwerkstack kann für Anwendungen eingeschränkt werden (Admin-Netzwerk für Anwendungen nicht sichtbar)
  • Docker unterstützt ein Implementations-Design, bei dem Anwendungs-Programme und Daten getrennt gehalten werden (Anwendungen in Container-Images, Daten in Speicher-Volumes ausserhalb der Container)
  • Über Dockerfiles sind die Container jederzeit reproduzierbar. Bei einem Einbruch in einen Docker-Container kann dieser zu Beweiszwecken eingefroren werden und durch ein neues, sauberes Container-Image ersetzt werden
  • Docker-Container werden nicht per Software-Update aktualisiert, sondern durch ein neues Container-Image mit aktueller Software ersetzt. Hierdurch kann sich ein (auch bisher unbemerkter) Einbrecher nicht im System festsetzen
• Nachteile:
  • die Isolierung von Anwendungen durch Linux-Container-Virtualisierung ist nicht so stark und vollständig wie bei einer Voll-Virtualisierung (VMWare, HyperV, VirtualBox). Linux-Container können jedoch innerhalb einer Voll-Virtualisierung eingesetzt werden und somit werden die Vorteile beider Systeme genutzt
  • Anwendungs-Installationen müssen angepasst werden, um Programme und Daten sauber zu trennen
  • Docker erhöht die Komplexität der Installation
  • Docker-Verwaltungswerkzeuge (Kubernetes etc) erhöhen die Komplexität und haben ggf. eigene Sicherheitsprobleme

• Docker installieren und starten

apt install docker.io

• Docker testen

docker run hello-world

• Docker Image herunterladen

# docker pull centos
# docker images

• Ein Centos mit Bash starten

# docker run --name=application1 -it centos /bin/bash
docker# yum update -y
docker# yum install -y procps httpd
docker# yum clean all
docker# exit
# docker ps -a

• mit laufendem Docker Container verbinden

docker attach application1

• Docker Container Statistiken

# docker top <container>
# docker stats <container1> <container2> ...

• einen weiteren Prozess im Docker Container ausfuehren

# docker exec -d <container> touch /etc/new-config
# docker exec -t -i <container> /bin/sh

• Docker Container stoppen

# docker stop application1

• Docker bei Applikations-Ende automatisch neu starten

docker run --restart=always
docker run --restart=on-failure:5

• Docker inspect -> Go Template https://golang.org/pkg/text/template/

docker inspect <container>
docker inspect --format '{{ .NetworkSettings.IPAddress }}' <container>

• Docker Container im Hintergrund (-d) starten

docker run --name <name> -d <image> <command>

• Ausgaben der Anwendung im Docker Container anschauen

docker logs <container>
docker logs -f <container>
docker logs --tail -f <container>
docker logs --tail 50 <container>

• Docker log drivers (json-file, syslog, none, …)

docker run --log-driver="syslog" ...

• Docker image bauen

mkdir -p docker-work
cd docker-work
vi Dockerfile
-----
# Debian with nginx
# Version 1
FROM debian:latest

MAINTAINER Linuxhotel Trainer

# Update image
RUN apt update
# Add httpd package. procps and iproute are only added to investigate the image later.
RUN apt -y install nginx
RUN echo container.example.com > /etc/hostname

# Create an index.html file
RUN bash -c 'echo "Your Web server test on Debian Docker Container is successful." >> /var/www/html/index.html'
# create a nginx start-command
CMD ["nginx", "-g", "daemon off;"]
------
docker build -t debian-nginx --no-cache .
docker run -d -t --name=deb-nginx1 -p 8080:80 debian-nginx

• Volumes

docker run -v <local-dir>:<container-dir>[:ro] ...

• Volumes im Dockerfile definieren. Hierdurch werden Volumes beim Erstellen des Containers ausserhalb des Containers erstellt (unter /var/lib/docker/... auf dem Linux-Host) und in den Container eingebunden

# Dockerfile
[...]
VOLUME /data
VOLUME /var/www/html

• installiere ein Image mit dem 'Caddy' Webserver (https://caddyserver.com) aus der Docker Hub Registry (abiosoft/caddy). Caddy ist ein in der Sprache go geschriebener Webserver, welcher automatisch TLS/x509 Zertifikate von Let's Encrypt besorgt und aktualisiert.
  • starte einen Container aus dem Image, mappe Port 2015 vom Container auf einen freien Port auf dem Host
  • teste die Caddy-Webseite mit dem Firefox auf dem Laptop http://localhost:<port>
  • starte eine Shell im Caddy-Webserver Container per docker exec. Suche das Verzeichnis mit den HTML-Dateien.
  • stoppe den Container, lösche den Container (docker rm)
  • erstelle ein leeres Verzeichnis auf dem Container-Host (Laptop) unter /srv/websites/html. Erstelle eine einfache HTML-Datei index.html in diesem Verzeichnis.
  • starte einen neuen Container, verbinde das Verzeichnis /srv/websites/html vom Container-Host in den Container (Parameter -v, siehe oben).
  • Teste den Webserver mit dem Firefox Browser
  • Ändere die Datei index.html unter /srv/websites/html, teste das die Änderungen im Browser sichtbar sind
  • Lösche den NGINX-Container
  • erstelle einen neuen NGINX Container, bei dem das Verzeichnis /srv/websites/html in den Webroot des NGINX-Webservers gemappt wird (Achtung: anderen Port als für den Caddy-Webserver benutzen. Beide Webserver-Container sollten zur gleichen Zeit aktiv sind)
  • Einige Befehle zum Probieren (als Benutzer root auf dem Host)

docker logs <container>   # Anzeige der Logausgaben des Hauptprozesses
docker top <container>    # Anzeige der Prozesse im Container
docker stats <container>  # Anzeige der vom Container benutzten Resourcen

• Docker Image History anschauen

docker images
docker history <image-name>

• Docker Image(s) in eine Datei sichern. Metadaten und Schichten bleiben erhalten

docker save -o mydockerapp.tar <image-name> [<image-name2>]

• Docker-Image aus einer Datei laden (welche mit docker save erstellt wurde)

docker load -i mydockerapp.tar

• Docker Container exportieren (nur das Dateisystem wird exportiert, die Schichten/Layer verschwinden)

docker ps -a
docker export -o mydockerapp.tar <container-name>
xz -v mydockerapp.tar

• Docker Container vom Tarball importieren

xzcat mydockerapp.tar.xz | docker import - <image-name>

• Docker Container in ein Image umwandeln (z.B. für forensische Analyse)

docker commit <container-ID> <image-name>

• Docker registry als Docker-Container starten. Die Docker Registry benutzt Port 5000/tcp.

docker run -d -p 5000:5000 registry

• Docker image „taggen“

docker images
docker tag <images-id> localhost:5000/debian-nginx:01

• Image in die Registry laden (push)

docker push localhost:5000/debian-nginx:01

• Docker Image lokal löschen (Achtung: Docker Images können erst gelöscht werden, wenn keine aktiven under inaktiven Container dieses Image benuzten. Ggf. müssen erst die auf diese Images basierenden Container per docker rm <container> gelöscht werden)

docker rmi localhost:5000/debian-nginx:01
docker rmi debian:latest
docker images

• Image aus der lokalen Registy (neu) laden

docker pull localhost:5000/debian-nginx:01

• wenn die Kommunikation zwischen Registry und Docker-Client nicht über die Loopback-Schnittstellen läuft (nicht localhost), dann muss diese Kommunikation mit TLS/SSL abgesichert sein. Dazu muss auf der Registry ein x509 Zertifikat installiert werden. Optionen:
  • von Let's Encrypt ein x509 Zertifikat besorgen und einbauen. Da Let's Encrypt Zertifkate nur 3 Monate gültig sind, sollte dieser Prozess automatisiert und überwacht sein
  • ein x509 Zertifikat von einer Zertifizierungsstelle (CA) kaufen
  • Option ohne TLS: per SSH einen Tunnel von Port 5000 des Clients auf Port 5000 des Registry-Hosts aufbauen und den Docker-Client gegen den „localhost“ Port laufen lassen. Bonus: per Systemd-Socket-Activation auf dem Client kann der SSH-Tunnel automatisch aufgebaut werden.
• Liste der Images in einer lokalen Registry laden und anzeigen

curl -X GET http://localhost:5000/v2/_catalog | python -m json.tool

• Top ten most popular docker images each contain at least 30 vulnerabilities (Februar 2019): https://snyk.io/blog/top-ten-most-popular-docker-images-each-contain-at-least-30-vulnerabilities/

• keine SUID Programme im Container
• keinen "echten" Benutzer "root" (UID0) im Container (Capabilities benutzen)
• Anwendungen im Container nicht unter einem Root-Account betreiben
• Capabilities sparsam einsetzen (kein CAP_SYS_ADMIN)
• Dateien in /tmp sind keine Daten, nicht von extern mounten
• Programme (im Container) und Daten (ausserhalb des Containers) trennen
• sensitive Programme read-only in den Container mappen/mounten
• Container auf bekannte Sicherheitslücken der im Container benutzen Software überwachen
• Container oft und regelmässig auffrischen

• Beispiel-Regelwerk (generisch, muss ggf. für die eigene Repository angepasst werden)

 -w /etc/docker -k docker
-w /etc/docker/key.json -k docker
-w /etc/docker/daemon.json -k docker
-w /etc/docker/certs.d -k docker
-w /etc/sysconfig/docker -k docker
-w /etc/sysconfig/docker-network -k docker
-w /etc/sysconfig/docker-storage -k docker
-w /etc/sysconfig/docker-storage-setup -k docker
-w /usr/lib/systemd/system/docker.service -k docker
-w /usr/bin/docker-containerd -k docker
-w /usr/bin/docker-containerd-current -k docker
-w /usr/bin/docker-containerd-shim -k docker
-w /usr/bin/docker-containerd-shim-current -k docker
-w /usr/bin/docker -k docker
-w /usr/bin/docker-current -k docker
-w /usr/bin/docker-ctr-current -k docker
-w /usr/bin/dockerd -k docker
-w /usr/bin/dockerd-current -k docker
-w /usr/bin/container-storage-setup -k docker
-w /var/lib/docker -k docker
-w /var/run/docker.sock -k docker

• in der Datei /etc/sysconfig/docker

dockerd --tlsverify ...

• in der Datei /etc/sysconfig/docker

dockerd --userns-remap=default ...

• in der Datei /etc/sysconfig/docker

dockerd --disable-legacy-registry ...

• in der Datei /etc/sysconfig/docker, Format --default-ulimit <ulimit-spec>=<soft-limit>:<hard-limit>
• Information ueber ULIMIT Schluesselwoerter in /etc/security/limits.conf
• Default-Ulimit setzen

dockerd --default-ulimit nofile=50:150 --default-ulimit nproc=10:20

• Ulimit fuer einzelnen Container

docker run --ulimit nofile=20:50 ...

docker run -u dockeruser -d ...

• Docker Container mit beschraenkten Capabilities starten

docker run --cap-drop=all --cap-add [notwendige capabilities] ...

• Capabilities eines Prozesses in einem Docker Container herausfinden am Beispiel des nginx Webservers

 # Prozess-ID des nginx Prozesses herausfinden
docker exec $(docker ps -q) pgrep -a nginx
# Capabilities der Prozess-ID 1 (nginx) abfragen
docker exec $(docker ps -q) cat /proc/1/status | grep CapEff | awk '{print $NF}'
00000000a80425fb
# Capabilties dekodieren und Docker-Parameter ausgeben
capsh --decode=00000000a80425fb | echo "--cap-drop=all --cap-add={$(sed -e 's/.*=//' -e 's/cap_//g')}"
--cap-drop=all --cap-add={chown,dac_override,fowner,fsetid,kill,setgid,setuid,setpcap,net_bind_service,net_raw,sys_chroot,mknod,audit_write,setfcap}

• Die Capabilities unter –cap-add pruefen und ggf. einschraenken

• die Datei /etc/localtime im Container Read-Only setzen, verhindert, das die Zeitzone im Container veraendert wird

docker run -v /etc/localtime:/etc/localtime:ro

Docker Parameter	Beschreibung
–cpu-period	Laenge der CPU CFS (Completely Fair Scheduler) Zeitscheibe
–cpu-quota	CPU CFS (Completely Fair Scheduler) quota
–cpuset-cpus	Container an CPUs binden (0-3, 0,1).
–cpuset-mems	Container an Speicher-Nodes binden (0-3, 0,1) nur fuer NUMA Maschinen
–kernel-memory	Kernel Speicher-Limit
-m, –memory	Speicher Limit
–memory-reservation	Limit fuer Speicherreservierungen (Virtueller noch nicht benutzer Speicher)
–memory-swap	Vollstaendiges Speicherlimit (memory + swap), '-1' schaltet virtuellen Speicher (SWAP) aus

• Das Root-Dateisystem im Container „nur-lesend“ einbinden

docker run --read-only ...

• Container Volume nur-lesend einbinden

docker run -v /volume:ro ...

• Pfade des Hosts nur-lesend in den Container einbinden

docker run -v /srv/container/name:/srv:ro ...

Für Linux-Sicherheits-Module (LSM) auf Label Basis (Role Based Access Control, RBAC) kann der Benutzer, die Rolle, der Tyoe und der Level für einen Container festgelegt werden. LSM funktionieren nicht innerhalb von Containers, sondern nur für einen gesamten Container.

docker run --security-opt=[label=user:USER]

• Docker mit AppArmor Profilen benutzen https://cloud.google.com/container-optimized-os/docs/how-to/secure-apparmor
• Docker Default AppArmor Profil: https://docs.docker.com/engine/security/apparmor/ https://github.com/docker/labs/tree/master/security/apparmor

• LWN A seccomp overview https://lwn.net/Articles/656307/
• Default Docker Seccomp Profile https://github.com/moby/moby/blob/master/profiles/seccomp/default.json
• Linux x86_64 syscall Tabelle https://filippo.io/linux-syscall-table/

  man syscalls
  

• Docker Container mit eigenem Seccomp Profil starten:

  docker run --security-opt=[seccomp=/pfad/zur/eignen/seccomo-profile.json]
  

• Gefahr eines Rowhammer Angriffs auf Speicherbereiche über VM/Containergrenzen https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/html/virtualization_tuning_and_optimization_guide/chap-ksm

# systemctl status ksm
● ksm.service - Kernel Samepage Merging
   Loaded: loaded (/usr/lib/systemd/system/ksm.service; enabled; vendor preset: enabled)
   Active: active (exited) since Mi 2017-10-25 19:20:35 CEST; 13h ago
  Process: 777 ExecStart=/usr/libexec/ksmctl start (code=exited, status=0/SUCCESS)
 Main PID: 777 (code=exited, status=0/SUCCESS)
    Tasks: 0
   Memory: 0B
   CGroup: /system.slice/ksm.service

Okt 25 19:20:35 notebook51 systemd[1]: Starting Kernel Samepage Merging...
Okt 25 19:20:35 notebook51 systemd[1]: Started Kernel Samepage Merging.

• Rowhammer Angriff: https://de.wikipedia.org/wiki/Rowhammer
• Attacking a co-hosted VM: A hacker, a hammer and two memory modules https://thisissecurity.stormshield.com/2017/10/19/attacking-co-hosted-vm-hacker-hammer-two-memory-modules/
• KSM ausschalten (mehrere Optionen)

# /usr/libexec/ksmctl stop
# echo 0 > /sys/kernel/mm/ksm/run
# systemctl disable ksm
# systemctl disable ksmtuned
# echo 2 > /sys/kernel/mm/ksm/run

• Forensik Live-Linux-CD-ROM bereithalten und regelmässig üben (1/2 jährlich)
• Kontaktadressen von Forensikern/Strafverfolgungsbehörden bereithalten
• das Erstellen von Platten-Images üben
• PGP/GPG Schlüssel erstellen und aktuell halten. PGP/GPG-E-Mail regelmässig benutzen, um in Übung zu bleiben
• Ersatz-Hardware vorhalten (Festplatten, SSD), Speicherplatz für Platten-Images
• Beutel für manipulationssichere Beweissicherung bestellen und "vor Ort" bereithalten
• Hardware-RAID meiden (Alternativen: Software RAID - DM-RAID, btrfs, zfs)
• alternative Kommunikationswege (Twitter, externes E-Mail-System, externer Web-Server) vorbereiten. Kunden über diese alternativen Kommunikationswege informieren!
• Minimale-Installationen benutzen
• Datensparsamkeit - nur Daten, die nicht gespeichert werden, können nicht mißbraucht werden -> Datenhaltung kostet
• Incident-Modus für die IT-Systeme definieren –> welche Teile der IT können im Fall eines Angriffs ohne starke Auswirkungen auf den Firmenbetrieb ausgeschaltet oder abgeschottet werden
• Incident-Modus automatisiert per Configuration-Management System anschalten –> Testen

• wenn die eigene Kommunikationsstruktur (z.B. E-Mail) betroffen ist, die alterntaiven Kommunikationswege benutzen
• dokumentierte Notfall-Prozedur zur Kunden-Kommunikation vorhalten und verteilen
• bei erkannten Angriffen 4 Augen-Prinzip beachten, nicht alleine arbeiten!

• VM Snapshots erstellen (per GPG signieren)
• von einem Forensik-Linux booten (Kali-Linux, Deft o.ä.)
• revisionssichere Images (dcfldd, aff4) erstellen http://www.osforensics.com/tools/create-disk-images.html

  apt install dcfldd
  dcfldd if=/dev/sda1 hash=sha256 hashwindow=100M sha256log=sha256.txt \
    hashconv=after bs=512 conv=noerror,sync split=100M splitformat=aa of=sda1.dd
  

• Images sofort nach der Erstellung per GPG signieren (mit externer Signaturdatei)
• erst Platten-Images erstellen, dann Log-Dateien etc. anschauen
• Festplatten ausbauen und durch fabrikneue Platten ersetzen, Festplatten mit kompromittiertem System versiegeln (lassen)
• Analyse des Einbruches auf den Read-Only-Dateisystem-Images (nicht auf den echten Platten, die echten Platten sind ein Beweismittel und dürfen nach der Versiegelung nicht angefasst werden)

• Server komplett neu aufsetzen (Docker dockerfile, Foreman/Ansible/Salt etc, VM Templates)
• Festplatte(n) austauschen
• nur Daten ohne ausführbare Teile (Maschinencode, Java, .NET, Python pyc, PHP, Scripte etc) zurückspielen
  • bei der Einrichtung der Server schon auf eine Trennung von System, Anwendungen und Daten achten!
• Scripte neu erstellen, von einem bekannt sauberen Backup zurückspielen oder einzeln per Pair-Review (2 Personen Review) prüfen

• rhash Installation

apt install rhash

• Datenbank mit den Hash-Werten erstellen (Hash=SHA3/Keccak mit 224 bit, Datenbankformat wie bei BSD)

rhash -r --sha3-224 --bsd /etc -o hash.lst

• Datenbank anschauen

less hash.lst

• Datenbank sichern (in Produktionsumgebung)

scp hash.lst benutzer@sicherer-server.example.com

• Dateien gegen die Datenbank prüfen

rhash -r -c --bsd hash.lst

• Die Benutzer-Authentisierungsdateien durch Anlegen eines neuen Benutzers ändern

adduser intruder

• nochmal Dateien gegen die Datenbank prüfen

rhash -r -c --bsd hash.lst

• Nur die "nicht-OK" Dateien anzeigen

rhash --skip-ok -r -c --bsd hash.lst

• Installation

apt install aide

• Konfiguration anschauen und ggf. ändern

$EDITOR /etc/aide/aide.conf
update-aide.conf
less /var/lib/aide/aide.conf.autogenerated

• AIDE Datenbank erstellen (Dauer ca. 3-6 Minuten auf den Linuxhotel Laptops)

aideinit

• Ausgabe von aideinit

Start timestamp: 2019-11-13 07:58:08 +0100 (AIDE 0.16.1)
AIDE initialized database at /var/lib/aide/aide.db.new
Verbose level: 6

Number of entries:      178250

---------------------------------------------------
The attributes of the (uncompressed) database(s):
---------------------------------------------------

/var/lib/aide/aide.db.new
  RMD160   : w/xQIwY8je09TrZAMFOFN2JqAY4=
  TIGER    : MRqyf0hq+8N+Kv/wILF7v0X3HEFcvhdv
  SHA256   : 8Jvgtqq0amatTf+Tj0o42W2HYne6Jf2g
             i5PClJmWv04=
  SHA512   : OWGC4zRYKyBTEg9fBBDgUCLVDoERZjve
             GI5EdEPCoGXwRnTR6tBP67tAa9tj7llh
             bd2O2CbTZ08pVI9AQ22Q2g==
  CRC32    : B9czIg==
  HAVAL    : 9GLjw3cDS/k2qpnZhoiZHmKYoSMZ1I3h
             mL2pUnyMoCQ=
  GOST     : mfBemqOHFSzWHf49h33R7gysjoLA4JiH
             oA+P3T9v6xU=

End timestamp: 2019-11-13 08:01:19 +0100 (run time: 3m 11s)

• Datenbank sichern

scp  /var/lib/aide/aide.db.new.gz user@secure-machine

• eine unbefugte Änderung am System simulieren

groupadd intruders

• AIDE Check laufen lassen

aide --check -c /var/lib/aide/aide.conf.autogenerated

• Installation

apt install samhain

• Samhain internen Schlüssel ergänzen (<key> sollte durch eine lange, zufällige Zahl ersetzt werden)

systemctl stop samhain
samhain --add-key=<key>@/usr/sbin/samhain
cp /usr/sbin/samhain.out /usr/sbin/samhain
rm -f /var/lib/samhain/samhain_file
systemctl start samhain

• Samhain Konfigurationsdatei anschauen/anpassen. Die Samhain Konfigurationsdatei ist noch nicht auf Debian 10 angepasst und sollte, um Fehlmeldungen zu vermeiden, an einigen Stellen (z.B. /bin, /sbin, /lib) geändert werden

$EDITOR /etc/samhain/samhainrc

• Datenbank auf einen sicheren Server kopieren (in Produktionsumgebungen)

scp /var/lib/samhain/samhain_file nutzer@secure-host:.

• Samhain ist als Service-Dämon gestartet

systemctl status samhain

• Test Passwort-Dateien ändern

# test, Datei (/etc/shadow und /etc/passwd) ändern
passwd nutzerXX

• Check mit Ausgaben nur Level "crit"

samhain -t check --foreground -l none -p crit

• Samhain Datenbank aktualisieren

samhain -t update --foreground

• YAMA sammelt Sicherheitsfunktionen aus Linux-Kernel-Sicherheitspatches, welche nicht in eine der anderen Linux-Sicherheits-Module passen
• in aktuellen Linux-Kerneln bietet mit YAMA einen Schutz gegen ptrace (ptrace_scope), d.h. das ein Prozess den Speicher und die Ausführung eines anderen Prozesses überwachen kann (diese Funktion wird für die Benutzung von Debuggern bei der Programmentwicklung benötigt). Auf Produktions-Serversystemen ist diese Funktion oft nicht benötigt.
• Werte für ptrace_scope

  Wert	Beschreibung
  0	normales Verhalten, jeder Prozess und Benutzer kann andere Prozesse überwachen
  1	ein Prozess kann nur einen eigenen Kind-Prozess überwachen
  2	nur ein Systemadministrator mit CAP_SYS_PTRACE kann Prozesse überwachen
  3	keine Überwachen von Prozessen mittels ptrace möglich, diese Einstellung kann im laufenden System nicht überschrieben werden

• AppArmor ist bei Debian 10 installiert und aktiviert
• AppArmor Wiki http://wiki.apparmor.net/index.php/Main_Page
• Installation weiterer AppArmor Tools

apt install apparmor apparmor-profiles apparmor-utils

• AppArmor Status prüfen

aa-status

• AppArmor Profil für ein Programm anschauen. Dokumentation der AppArmor Profil-Definition http://wiki.apparmor.net/index.php/AppArmor_Core_Policy_Reference

less  /etc/apparmor.d/bin.ping

• Änderungen am Profil für ping, das ping Programm sollte danach keine ICMP(v6) Pakete versenden können

$EDITOR /etc/apparmor.d/bin.ping
---
[...]
  #include <abstractions/nameservice>

#  capability net_raw,
#  capability setuid,
  network inet raw,
[...]

• Profil neu laden

apparmor_parser -r /etc/apparmor.d/bin.ping

• Enforce-Modus für ein Programm setzen

# aa-enforce  /etc/apparmor.d/bin.ping
Setting /etc/apparmor.d/bin.ping to enforce mode.

• Test des ping Programms:

# ping 8.8.8.8
ping: socket: Die Operation ist nicht erlaubt
# ping fe80::3e97:eff:feeb:a358%enp0s25
ping: socket: Die Operation ist nicht erlaubt

• Complain-Modus für ein Programm setzen

aa-complain  /etc/apparmor.d/bin.ping
Setting /etc/apparmor.d/bin.ping to complain mode.

• gestartete Programme ohne AppArmor Profil listen

# aa-unconfined
622 /usr/sbin/NetworkManager not confined
623 /usr/sbin/cupsd confined by '/usr/sbin/cupsd (enforce)'
630 /usr/sbin/avahi-daemon confined by '/usr/sbin/avahi-daemon (complain)'
650 /usr/sbin/cups-browsed confined by '/usr/sbin/cups-browsed (enforce)'
698 /usr/sbin/sshd not confined
1250 /usr/sbin/minissdpd not confined
1504 /usr/sbin/exim4 not confined
2013 /sbin/dhclient not confined

• AppArmor Profil-Vorlage automatisiert erstellen. Die Vorlage muss immer manuell nachgearbeitet werden. (Aufgrund des Debian-Fehlers https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=928160 funktioniert aa-genprof nicht wenn das Paket apparmor-profiles installiert ist. Um aa-genprof zu benutzen erst dieses Paket deinstallieren apt remove apparmor-profiles und dann aa-genprof benutzen).

aa-genprof <programm>

• wir arbeiten auf einer VM im Internet. Benutzername nutzer und Passwort villa, Benutzer root hat das Passwort vogelsang.

Hostname	IP-Adresse	Teilnehmer
VM01	167.172.176.65	Moritz
VM02	165.22.94.139	Christian
VM03	104.248.44.206	Ulf
VM04	104.248.16.216	Andy
VM05	167.172.176.135	Svenja
VM06	167.172.176.60	Björn
VM07	104.248.134.210	Stefan
VM08	167.172.176.233	Nico
VM09	165.22.24.31	Carsten

• SELinux Hilfspakete installieren

yum install policycoreutils setools libselinux-utils selinux-policy-doc setools-console
  \ policycoreutils-python selinux-policy-devel policycoreutils-newrole

• SELinux Label (Context) auf Dateien/Prozesse/Benutzer anzeigen

ls -lZ <pfad>
ps -auxZ
id -Z

• SELinux Status abfragen

getenforce
sestatus
sestatus -v

• SELinux Module auflisten

semodule -l | less

• Modul-Dateien (binär) und die fertige Policy

ls -l /etc/selinux/targeted/active/modules/100/
ls -lh /etc/selinux/targeted/policy/

• SELinux Policy Quelldateien

ls -l /usr/share/selinux/devel/

• Apache Webserver installieren und starten

yum install httpd
systemctl enable --now httpd

• Kleine Webseite anlegen

$EDITOR /var/www/html/index.html

• Inhalt der HTML-Datei

<html>
<body>
<h1>Apache Webserver</h1>
</body>
</html>

• SELinux Security Context auf der Datei

ls -lZ /var/www/html/index.html

• Wikipedia "Intel Management Engine" https://en.wikipedia.org/wiki/Intel_Management_Engine
• BSI warnt vor Risiko bei Intels Fernwartungstechnik AMT http://www.heise.de/newsticker/meldung/BSI-warnt-vor-Risiko-bei-Intels-Fernwartungstechnik-AMT-2792791.html
• Secret of Intel Management Engine by Igor Skochinsky http://de.slideshare.net/codeblue_jp/igor-skochinsky-enpub
• ME-Blockade - Linux-Tüftler schalten Intels Management Engine aus https://www.heise.de/ct/ausgabe/2017-4-Linux-Tueftler-schalten-Intels-Management-Engine-aus-3612223.html
• Intel-ME-Sicherheitslücke: Erste Produktliste, noch keine Updates https://www.heise.de/security/meldung/Intel-ME-Sicherheitsluecke-Erste-Produktliste-noch-keine-Updates-3703356.html
• Intel-Fernwartung AMT bei Angriffen auf PCs genutzt https://www.heise.de/security/meldung/Intel-Fernwartung-AMT-bei-Angriffen-auf-PCs-genutzt-3739441.html

Coreboot ist eine freie (open source) Firmware für Intel und ARM Rechner. Coreboot hiess früher LinuxBIOS.

• http://coreboot.org
• http://libreboot.org

• Audit-Subsystem anschalten

audit=[0|1]

• wenn audit nicht gesetzt ist, dann wir das Audit-Subsystem erst mit dem Starten des Audit-Daemon auditd aktiv
• Wert 0 – Audit-Subsystem ist ausgeschaltet
• Wert 1 – Audit-Subsystem wird sofort aktiv, der Kernel sammelt Audit Informationen und übergibt diese an den Audit-Daemon, sobald dieser gestartet ist

apparmor=[0|1]

• AppArmor an/ausschalten

• SELinux an/ausschalten

selinux=[0|1]

• SELinux Regeln durchsetzen (enforcing)

enforcing=[0|1]

• Wert 0 = SELinux im permissive Modus
• Wert 1 = SELinux im enforcing Modus

module.sig_enforce

• wenn gesetzt, können nur Kernel-Module mit einer gültigen Signatur geladen werden

noexec=[on|off]

• bei 32bit PAE Kerneln, schaltet Schreibschutz auf Daten-Speicherseiten an

no_file_caps

• Schaltet die Datei-Capabilities aus

nomodule

• es können keine Module nachgeladen werden

panic=<timeout>

• Wert > 0 - Sekunden bis zum Reboot
• Wert = 0 - kein Reboot (* aus Sicherheitsgründen empfohlen)
• Wert < 0 - sofortiger Reboot

• Übersicht- sysctl Parameter-Tuning: https://klaver.it/linux/sysctl.conf

sysctl -a

• Permanente sysctl Einstellungen in /etc/sysctl.conf

kernel.randomize_va_space = 2

# Restrict core dumps
fs.suid_dumpable = 0

# Hide exposed kernel pointers
kernel.kptr_restrict = 1

#Prevent SYN attack, enable SYNcookies (they will kick-in when the max_syn_backlog reached)
# use iptables synproxy
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_syn_retries = 2
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_max_syn_backlog = 4096

# Disables packet forwarding
net.ipv4.ip_forward = 0
net.ipv4.conf.all.forwarding = 0
net.ipv4.conf.default.forwarding = 0
net.ipv6.conf.all.forwarding = 0
net.ipv6.conf.default.forwarding = 0

# Disables IP source routing
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.default.accept_source_route = 0
net.ipv6.conf.all.accept_source_route = 0
net.ipv6.conf.default.accept_source_route = 0

# Enable IP spoofing protection, turn on source route verification
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# Disable ICMP Redirect Acceptance
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.secure_redirects = 0
net.ipv4.conf.default.secure_redirects = 0

# Enable Log Spoofed Packets, Source Routed Packets, Redirect Packets
net.ipv4.conf.all.log_martians = 1
net.ipv4.conf.default.log_martians = 1

# Don't relay bootp
net.ipv4.conf.all.bootp_relay = 0

# Don't proxy arp for anyone
net.ipv4.conf.all.proxy_arp = 0

# Enable ignoring broadcasts request
net.ipv4.icmp_echo_ignore_broadcasts = 1

# Enable bad error message Protection
net.ipv4.icmp_ignore_bogus_error_responses = 1

• Spezifikation: https://www.first.org/cvss/specification-document

sudo apt install tor

• Tor-Konfigurationsdatei editieren

sudo /etc/tor/torrc

• in der Datei die Sektion für Hidden Services suchen und einen Service definieren

HiddenServiceDir /var/lib/tor/ssh/
HiddenServicePort 22 127.0.0.1:22

• der Konfigurationsbefehl HiddenServiceDir gibt an, in welchem Verzeichnis die Tor-Software die Informationen zum Dienst ablegen soll (privater Schlüssel und Hostname/öffentlicher Schlüssel). Dieses Verzeichnis sollte noch nicht existieren und wird von der Tor-Software automatisch mit den korrekten Rechten angelegt.
• der Konfigurationsbehehl HiddenServicePort gibt an, welcher Port im Tor-Netzwerk sichtbar sein soll, und auf welchem Rechner (IP-Adresse) und Port die Pakete weitergeleitet werden sollen. Dabei kann auch eine IP-Adresse eines anderen Rechners im Netz angegeben werden, auf dem dann die Tor-Software nicht laufen muss, welcher aber als Onion-Service erreichbar ist.
• Nun die Tor-Software neu starten

# modernes Linux (systemd)
sudo systemctl restart tor

• in der Datei hostname des für den Onion-Dienst angegebenen Verzeichnis befindet sich der Onion-Name des Dienstes. Mit diesem Namen kann der Dienst erreicht werden. Der Client muss dabei auch die Tor-Software installiert haben und das Tor-Netz benutzen.

cat /var/lib/tor/ssh/hostname                                                    
rhbmhbl3n5iljqkj.onion

• Tor-Software installieren und starten (keine besondere Konfiguration erforderlich)
• für Web-Anwendungen den Tor-Browser installieren und benutzen: https://www.torproject.org/projects/torbrowser.html.en
• oder im Browser (Firefox, Seamonkey, Chromium etc) in den Netzwerkeinstellungen als Proxy einen Socks5 Proxy auf Port 9050 eintragen. Einstellen, das DNS-Anfragen auch über den Socks5-Proxy gesendet werden.
• Dienste, welche keinen Socks5-Proxy unterstützen, können über den Befehl torify das Tor-Netzwerk benutzen. Dabei fängt torify DNS-Anfragen und Netzwerkverbindungen an das Internet ab und leitet diese Anfragen an das Tor-Netzwerk weiter. Beispiel SSH (Secure Shell):

$ torify ssh rhbmhbl3n5iljqkj.onion
The authenticity of host 'rhbmhbl3n5iljqkj.onion (127.42.42.0)' can't be established.
ECDSA key fingerprint is SHA256:UDnhiUeJdxYVlYJHM/cOmP4gh+a6jKO+dfYwH0J8fDc.
ECDSA key fingerprint is MD5:8e:cc:bf:07:ee:bb:a7:9e:5f:77:f7:10:12:01:01:fa.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'rhbmhbl3n5iljqkj.onion' (ECDSA) to the list of known hosts.
root@rhbmhbl3n5iljqkj.onion's password: 
box$

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

Die Dienste-Authentisierung wird auf der Server-Seite mit der Konfigurationsdirektive HiddenServiceAuthorizeClient angeschaltet. Diese Direktive nimmt als Parameter den Authentisierungs-Modus (basic oder stealth) und eine per Komma getrennte Liste an Client-Namen. Diese Client-Namen sind nur beschreibener Natur und müssen nicht mit Hostnamen oder Domain-Namen übereinstimmen. Die Direktive gilt für den jeweils voher definierten Onion-Dienst:

HiddenServiceDir /var/lib/tor/ssh/
HiddenServicePort 22 127.0.0.1:22
HiddenServiceAuthorizeClient stealth client1,client2,client3

Nach einem Neustart des Tor-Dienstes findet sich im Verzeichnis des Onion-Dienstes eine neue Datei mit dem Dateinamen client_keys. Diese Datei enthält die Authentisierungs-Cookies und privaten Schlüssel für jeden angegebenen Client-Rechner:

client-name client1
descriptor-cookie QJVF38CnraTrg8FaAHuvFw==
client-key
-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQDTcZOJO3Eh4GWva8L9I4MlabqAvujx6oCL3xso00NTX6zWNWZn
[...]
6rEwyC92BYs2rShFsGadG0ET6N6+j7uWNf18Ya+qikCl
-----END RSA PRIVATE KEY-----
client-name client2
descriptor-cookie m6Isl8df2gPV+MBDoYFNLw==
client-key
-----BEGIN RSA PRIVATE KEY-----
MIICWwIBAAKBgQC/OSyIWcTGD9oZK3vUqeTpSIJkpkJc670/c57iXo6a6L94VW/0
[...]
NFd2QdCnL87ay3gxjTx9APvGdDRf6VaMNaSurciq2Q==
-----END RSA PRIVATE KEY-----

In der Datei hostname im Verzeichnis des Onion-Dienstes befinden sich nun unterschiedliche Onion-Namen für die jeweiligen Clients, zusammen mit den Authentisierungs-Cookies:

iaopwbjmex2splr2.onion QJVF38CnraTrg8FaAHuvFx # client: client1
bdc5ujizach44dwm.onion m6Isl8df2gPV+MBDoYFNLx # client: client2
kura5sy7vsmi6ws6.onion wyThiRFLyqtsppBS0TDoHB # client: client3

Aus dieser Datei muss nun für jeden Client der Onion-Namen und der dazugehörige Cookie in die Konfiguration der Tor-Software auf den jeweiligen Clients kopiert werden.

Onion-Namen und Cookie werden auf Client-Seite mit der Direktive HidServAuth in die Konfigurationsdatei /etc/tor/torrc eingetragen:

HidServAuth  kura5sy7vsmi6ws6.onion wyThiRFLyqtsppBS0TDoHB # client: client3

Nach einem Neustart der Tor-Software auf dem Client sollte nun der Onion-Dienst von diesem Client aus sichtbar und benutzbar sein.

Ein Verbindungsaufbau zum Dienst ohne den Authentisierungs-Cookie bedingt einen Timeout:

# torify ssh -v kura5sy7vsmi6ws6.onion
OpenSSH_7.5p1, OpenSSL 1.1.0f-fips  25 May 2017
debug1: Reading configuration data /etc/ssh/ssh_config
debug1: Reading configuration data /etc/ssh/ssh_config.d/05-redhat.conf
debug1: Reading configuration data /etc/crypto-policies/back-ends/openssh.config
debug1: /etc/ssh/ssh_config.d/05-redhat.conf line 8: Applying options for *
debug1: Connecting to kura5sy7vsmi6ws6.onion [127.42.42.0] port 22.
[Aug 03 22:26:45] ERROR torsocks[9052]: Connection timed out (in socks5_recv_connect_reply() at socks5.c:536)
debug1: connect to address 127.42.42.0 port 22: Connection timed out
ssh: connect to host kura5sy7vsmi6ws6.onion port 22: Connection timed out

Mit dem korrektem Cookie funktioniert der Verbindungsaufbau:

# torify ssh -v kura5sy7vsmi6ws6.onion
OpenSSH_7.5p1, OpenSSL 1.1.0f-fips  25 May 2017
debug1: Reading configuration data /etc/ssh/ssh_config
debug1: Reading configuration data /etc/ssh/ssh_config.d/05-redhat.conf
debug1: Reading configuration data /etc/crypto-policies/back-ends/openssh.config
debug1: /etc/ssh/ssh_config.d/05-redhat.conf line 8: Applying options for *
debug1: Connecting to kura5sy7vsmi6ws6.onion [127.42.42.0] port 22.
debug1: Connection established.
[...]
debug1: SSH2_MSG_KEXINIT sent
debug1: SSH2_MSG_KEXINIT received
debug1: kex: algorithm: curve25519-sha256@libssh.org
debug1: kex: host key algorithm: ecdsa-sha2-nistp256
debug1: kex: server->client cipher: aes256-gcm@openssh.com MAC: <implicit> compression: none
debug1: kex: client->server cipher: aes256-gcm@openssh.com MAC: <implicit> compression: none
debug1: kex: curve25519-sha256@libssh.org need=32 dh_need=32
debug1: kex: curve25519-sha256@libssh.org need=32 dh_need=32
debug1: expecting SSH2_MSG_KEX_ECDH_REPLY
debug1: Server host key: ecdsa-sha2-nistp256 SHA256:UDnhiUeJdxYVlYJHM/cOmP4gh+a6jKO+dfYwH0J8fDc
The authenticity of host 'kura5sy7vsmi6ws6.onion (127.42.42.0)' can't be established.
ECDSA key fingerprint is SHA256:UDnhiUeJdxYVlYJHM/cOmP4gh+a6jKO+dfYwH0J8fDc.
ECDSA key fingerprint is MD5:8e:cc:bf:07:ee:bb:a7:9e:5f:77:f7:10:12:01:01:fa.
Are you sure you want to continue connecting (yes/no)? 

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

• https://riseup.net/de/security/network-security/tor/onionservices-best-practices
• http://www.tompurl.com/2015/10/06/connecting-to-an-ssh-tor-hidden-service/
• http://www.nurdletech.com/linux-notes/ssh/hidden-service.html
• https://www.torproject.org/docs/tor-hidden-service.html.en
• Etherpad im TOR Netzwerk: http://5jp7xtmox6jyoqd5.onion/

• Berkeley-DB Development-Dateien laden

apt install libdb-dev build-essential

• NBS Quellcode laden und auspacken

cd ~/src
wget http://www.ranum.com/security/computer_security/code/nbs.tar
tar xvf nbs.tar
cd nbs

• NBS Quellcode patchen

sed -i 's/.*extern\tint\terrno;.*/#include <errno.h>/' nbspreen.c

• NBS Quellcode bauen und Programm-Dateien installieren

make
cp nbs nbsmk nbspreen nbsdump /usr/local/bin

• Verzeichnis für NBS Dateien anlegen

mkdir /var/lib/nbs

• Datenbank für NBS anlegen

cd /var/lib/nbs
nbsmk -d messages.nbs

• Datenbank mit Log-Daten anlernen

nbs -d messages.nbs -i /var/log/messages -s
[...]
NBS completed run (0 sec)
9567 never before seen entries
13630 lines of input processed (70.19% NBS)
9567 total entries in database

• Neuen Log-Eintrag simulieren

logger -t nbstest "Hallo, dies ist ein Test"

• NBS Lauf

nbs -d messages.nbs -i /var/log/messages -s

• Ausgabe

nbs -d messages.nbs -i /var/log/messages -s
Aug 30 08:17:48 notebook32 nbstest: Hallo, dies ist ein Test
NBS completed run (0 sec)
1 never before seen entries
13631 lines of input processed (0.01% NBS)
9568 total entries in database

• die NBS Ausgabe kann auch in eine Datei geschrieben oder angehangen werden

nbs -d /var/lib/nbs/messages.nbs -i /var/log/messages -a /var/log/nbs.log

• Log-Templater ist eine Software zur Implementation von AI-Logauswertung
  • http://www.uberadmin.com/Projects/logtemplater/
  • https://github.com/rondilley/tmpltr
• Log-Templater installieren

mkdir ~/src
cd ~/src
apt -y install git build-essential automake autoconf
git clone https://github.com/rondilley/tmpltr.git
cd tmpltr
./bootstrap
autoreconf -i
./configure
make
make install

• Systemd-Journal für den Dienst sshd mit tmpltr auswerten

journalctl -u ssh | tmpltr - | sort -n |  sed -e 's/%s.*||//'

• Templates abspeichern, dann ignore Datei bearbeiten

journalctl -u ssh | tmpltr -w /var/log/ssh.ignore -

• Log mit ignore Datei auswerten

journalctl -u ssh | tmpltr -t /var/log/ssh.ignore - | sort -n |  sed -e 's/%s.*||//'

• SSH-Fehler produzieren (z.B. Anmeldeversuch mit falschem Passwort) und Log-Datei neu auswerten

ssh bar@localhost
bar@localhost's password:
Permission denied, please try again.
bar@localhost's password:

• Log-Auswerten

[bar@notebook32 tmpltr]# journalctl -u sshd | tmpltr -t /var/log/sshd.ignore - | sort -n |  sed -e 's/%s.*||//'
Opening [-] for read
           1 Aug 31 12:29:25 notebook32 sshd[24691]: Connection closed by ::1 port 40372 [preauth]
           1 Aug 31 12:29:25 notebook32 sshd[24691]: Failed password for bar from ::1 port 40372 ssh2
           1 Aug 31 12:29:23 notebook32 sshd[24691]: pam_succeed_if(sshd:auth): requirement "uid >= 1000" not met by user "bar"
           1 Aug 31 12:29:23 notebook32 sshd[24691]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ruser= rhost=localhost  user=bar

• Neue Log-Einträge in die Ignore-Datei aufnehmen

journalctl -u sshd | tmpltr -t /var/log/sshd.ignore -w /var/log/sshd.ignore.new - && \
  cat /var/log/sshd.ignore.new >> /var/log/sshd.ignore

# nft "add rule ip fw input drop"

# nft -ia
nft> list ruleset
table inet workstation-fw {
    chain input {
             type filter hook input priority 0;
    }
}

nft> add rule inet workstation-fw input tcp dport {ssh, http} accept
nft> list ruleset
table inet workstation-fw {
    chain input {
             type filter hook input priority 0;
             tcp dport { ssh, http} accept # handle 3
    }
}
nft> quit

• Der Befehl flush löscht Objekte aus der nftables Kernel-Firewall.
• Ein flush ruleset löscht die gesamten Firewall-Regeln.
• Ein flush ruleset sollte am Anfang eines nftables-Regelsatzes stehen:

# nft flush ruleset

• Über flush chain und flush table können Ketten und Tabellen gelöscht werden.

• Der Befehl add fügt die Regel immer am Ende der Kette an
• mit insert kann eine Regel an einer beliebigen Stelle der Kette eingefügt werden.

• Der Befehl delete löscht eine Regel aus einer Kette. Zum Löschen einer Regel wird das Handle der Regel benötigt, das Handle wird über den Kommandozeilenparameter -a ausgegeben:

# nft -a list ruleset
...
ip6 saddr 2001:db8::/64 # handle 15
...
# nft delete rule inet filter input handle 15

Mittels nft monitor können Änderungen in der nftables-Firewall überwacht werden.

Der Befehl schreibt Modifikationen im Regelsatz der Firewall als nft-Befehlszeilen (Alternativ als XML oder JSON) auf die Konsole:

# nft monitor
add table inet filter
add chain inet filter input { type filter hook input priority 0; }
add rule inet filter input iif lo accept
add rule inet filter input ct state established,related accept
add rule inet filter input ip6 daddr ff02::1010 udp dport ntp accept
add rule inet filter input ip6 daddr ff02::fb udp dport mdns accept
add rule inet filter input ip daddr 224.0.0.251 udp dport mdns accept
add rule inet filter input ip6 saddr & :: == :: udp dport dhcpv6-client accept
add rule inet filter input udp dport ipp accept
add rule inet filter input ip6 saddr & :: == :: icmpv6 
      type { nd-neighbor-solicit, nd-router-advert, nd-neighbor-advert} accept
add rule inet filter input ip6 saddr & :: == :: icmpv6 
      type { echo-reply, echo-request, packet-too-big, destination-unreachable, 
             time-exceeded, param-problem} accept
add rule inet filter input counter packets 0 bytes 0 log prefix "nftables drop: " drop

• die aus iptables bekannten Konzepte von Tabellen (Tables) und Ketten (Chains) finden sich auch in nftables wieder
• vordefinierten Tabellen (in iptables 'filter', 'nat' und 'mangle') gibt es im nftables nicht
• Auch die in iptables vorhandenen Ketten ('input', 'output', 'forward') sucht man vergebens
• nftables kommt ohne vordefinierte Tabellen und Ketten.
• Die vordefinierten Ketten in iptables sind ein Performance-Problem bei grossen Datenmengen, da Netzwerkpakete auch durch unbenutze, leere Ketten geschleusst werden.
  • Unter nftables sind nur Tabellen und Ketten aktiv, welche der Administrator definiert hat.
• In nftables sind Tabellen einfache Container für beliebige Ketten.
• Eine Tabelle muss einem Protokoll zugewiesen werden (ip = IPv4, arp,/ip6/ = IPv6, bridge).
• Die Tabellen können beliebige Namen haben, auch wenn in vielen Beispielen im Internet die aus iptables bekannten Namen verwendet werden.
  • Bei den Ketten (Chains) unterscheidet man "base-chains" und "auxiliary chains".
  • Bei den "base-chains" handelt es sich um Ketten, welche in den Paketfluss des Netfilter-Framework eingeklinkt werden.
  • Diese Ketten erhalten Netzwerkpakete aus den Zugriffspunkten (Hooks) des Linux-Kernels.
  • Diese Zugriffspunkte für eine Kette vom Typ "filter" heissen "input", "output" und "forward".
  • Die Konzepte sind von iptables übernommen worden, der Firewall-Administrator hat nun aber mehr Freiraum, die Ketten zu organisieren.

• Beispiel einer Tabelle mit zwei (leeren) "filter" Ketten, für "input" und "output":

table inet filter01 {
        chain input01 {
                type filter hook input priority 0;
        }
        chain output01 {
                type filter hook output priority 0;
        }
}

• Mit dem Schlüsselwort hook wird eine Kette mit den Linux-Kernel-Internen Schnittstellen des Netfilter-Frameworks verbunden.
• Eine Kette mit Verbindung zum den Kernel-Schnittstellen ist eine "base-chain".
• Zusätzlich zu den "base-chains" kann der Administrator noch beliebig weitere "auxiliary chains" erzeugen.
• Diese Chains erhalten nur Netzwerkpakete, wenn diese aus einer "base-chain" per goto oder jump Direktive an die "auxiliary chain" verteilt werden:

table inet filter01 {
        # auxiliary chain 
        chain link-local-aux01 {
                 counter packets 0 bytes 0 log prefix "link-local: " accept
                 # weitere Regeln für link-local IPv6 
                 [...]
        }
        # base chain
        chain input01 {
                type filter hook input priority 0;
                ip6 daddr fe80::/64 jump link-local-aux01
        }
        # base chain
        chain output01 {
                type filter hook output priority 0;
        }
}

• Eine Hauptaufgabe einer Firewall ist das Filtern von Netzwerkverkehr.
• Die nftables-Firewall bietet umfangreiche Möglichkeiten, Netzwerkpakete in Filterregeln auszuwählen:
  • nach Quell- und Ziel-Adressen
  • UDP- und TCP-Ports
  • Meta-Informationen wie
    • Netzwerk-Interfaces
    • Protokolle
    • Hardware-MAC-Adressen
    • VLAN-Informationen
    • Status einer IP-Verbindung (Connection-Tracking)

• In diesem Beispiel wird eine Regel der Firewall hinzugefügt. Gefiltert wird nach der IPv6-Zieladdresse daddr ff02::fb und dem UDP-Port dport mdns (Multicast-DNS):

# nft "add rule inet filter input ip6 daddr ff02::fb udp dport mdns accept"

• Eine Liste der Filter-Optionen findet sich in der man-Page zu nft.

• Am Ende einer Firewall-Regel wird das Urteil (Verdict) über eine Netzwerk-Verbindung getroffen, das sogennante Verdict-Statement.
• Es gibt entgültige Urteile, welche die Bearbeitung eines Netzwerkpaketes sofort beenden.
• Dazu zählen * accept (Paket passieren lassen) * drop (Paket ohne Rückmeldung an den Sender verwerfen) und * reject (mit Rückmeldung verwerfen).
• Bei reject kann optional die ICMP-Meldung spezifiziert werden, welche an den Sender des Paketes zurückgeliefert wird:

# nft "add rule inet filter input ip6 saddr 2001:db8::/64" \
      "reject with icmpv6 type admin-prohibited"

Neben den entgültigen Urteilen kann eine Regel die Bearbeitung eines Paketes auch an anderen Stelle fortsetzen:

• continue Bearbeitung des Paketes mit die nächsten Regel in der Kette
• jump <chain> verzweigt die Bearbeitung wie ein Unterprogrammaufruf in eine andere Kette. Am Ende der neuen Kette wird die Bearbeitung in der ursprünglichen Kette weitergeführt.
• goto <chain> wird direkt in eine andere Kette gesprungen, ohne das die Bearbeitung jemals wieder zurückkehrt.
• queue verzweigt die Verarbeitung an ein externes Programm im Userspace.
• return beendet die Bearbeitung der aktuellen Kette an dieser Stelle. Wird return in einer Kette der obersten Bearbeitungsebene verwendet, so wird das Paket durch die Firewall gelassen (identisch zu einem accept).

• Über das Befehlswort log werden Informationen zu dem gerade bearbeiteten Netzwerk-Paket in das Kernel-Log (und damit in den meisten Systemen auch in das System-Log) geschrieben.
• Der Befehl counter erzeugt einen Zähler für diese Firewall-Regel.
• Anders als bei iptables müssen Counter für Regeln explizit erzeugt werden. Dies hat Performance-Gründe, die Zähler werden nur dann mitgeführt, wenn der Administrator diese im Regelsatz angefordert hat.
• In dem Zähler werden die Anzahl der gefilterten Pakete und die Datenmenge in Bytes gezählt.
• Der Zähler wird beim Auflisten des Regelwerkes, z.B. mit list ruleset, ausgegeben.

• Die Position des Befehls log in der Regel wichtig:
  • Steht der Befehl vor der Filter-Bedingung, so wird ein Log-Eintrag für jedes Paket geschrieben, welches von dieser Regel gesehen wird, unabhängig ob die Regel danach aktiv wird oder nicht.
  • Steht jedoch der Befehl log nach der Filterbedingung, so wird der Log-Eintrag nur geschrieben, wenn die Filterbedingung zutrifft.
• Gleiches gilt für die Position des Befehls counter.

# schreibe einen Log-Eintrag für jedes Paket 
# welches von dieser Regel gesehen wird
log tcp dport { 22, 80, 443 } ct state new accept
# schreibe einen Log-Eintrag nur wenn die Regel zutrifft
tcp dport { 22, 80, 443 } ct state new log counter accept

• Dem Befehl log kann mit dem Parameter prefix eine beliebige Zeichenkette mitgegeben werden.
• Diese Zeichenkette erscheint vor jeder Log-Meldung und wird benutzt, um Log-Einträge zu finden und zu filtern.

• Neben den Protokollen ip für IPv4 und ip6 für IPv6 unterstützt nftables auch das Pseudo-Protokoll inet für kombinierte IPv4- und IPv6-Filter.
• Anstatt z.B. Port 80 für einen Webserver in zwei getrennten Regeln für je IPv4 und IPv6 freizugeben, kann dies in nftables in nur einer Regel geschehen.
• Bei einem Server mit Dual-Stack und vielen Diensten kann dies das Regelwerk vereinfachen.
• Für das Protokoll inet muss eine eigene Tabelle mit Chains erstellt werden.

table inet filter {
    chain input { 
       ...
    }
}

• Die Tabelle mit dem Pseudo-Protokoll inet existiert paralell zu Tabellen mit IPv4- und IPv6-Regeln.
• Werden Tabellen mit dedizierten IPv4 und IPv6 Regeln genutzt, so müssen die Pakete sowohl in der inet Tabelle als auch in der jeweiligen Tabelle für das IP-Protokoll erlaubt werden.
• Um Fehler zu vermeiden, sollte entweder kombinierte inet Tabellen, oder protokoll-spezifische Tabellen benutzt werden, aber nicht beides.

• nftables bietet verschiedene Datenstrukturen, welche die Erstellung eines Regelwerkes vereinfachen:
  • Variablen
  • Intervalle
  • Sets
  • benannte und anonyme Maps
  • benannte und anonyme Dictionaries/Verdict-Maps

• Variablen erlauben symbolische Namen für Werte und IP-Adressen in einem nftables-Regelwerk.
• Variablen sind jeweils in der Umgebung sichtbar, in der sie definiert wurden (Table, Chain).
• Variablen werden über das Schlüsselwort define deklariert und mit einem Wert versehen. Im Regelwerk wird dann der Variablenname mit einem vorangestellem Dollar-Zeichen "$" verwendet, vergleichbar mit Variablen der Unix-Shell.

define lan_if = eth0
define DMZ-Dienste = { ssh, smtp, dns, http, https }
add rule inet filter input iif $lan_if tcp dport $DMZ-Dienste accept

• Intervalle in nftables sind Wertefolgen mit einem Start- und End-Wert.
• Intervalle werden z.B. für IP-Adresse-Bereiche und TCP/UDP-Port-Bereiche verwendet.

nft "add rule inet filter input ip6 daddr 2001:db8::0-2001:db8::1000 drop"
nft "add rule inet filter input tcp dport 0-1023 drop"

• Sets definieren eine Sammlung von Werten eines gleichen Typs. Ein Set wird durch geschweifte Klammern eingeleitet und die Elemente des Sets werden mit Komma getrennt.
• Ein anonymes Set mit Port-Nummern (Microsoft SMB/CIFS-Protokoll):

nft "add rule inet filter input udp dport { 137, 138, 139, 445 } reject" 

• Bei der Anlage eines benannten Sets muss nftables der Werte-Typ mitgeteilt werden.
• Eine (leider noch unvollständige) Liste der verfügbaren Werte-Typen ist in der nft man-Page aufgelistet:

nft "add set inet filter bogus { type ipv4_addr; }"
nft "add element inet filter bogus { 203.0.113.0; }"
nft "add element inet filter bogus { 203.0.113.1; }"
nft "add rule inet filter input ip saddr @bogus drop"
nft "list set inet filter bogus"

• Der letzte Befehl des Beispiel gibt den aktuellen Inhalt des benannten Sets bogus aus.
• Ein benanntes Set kann in einer Regel mit vorangestelltem "@" eingefügt werden.
• Eine Filterregel mit benanntem Set wird vom der nftables Virtuellen-Maschine schneller bearbeitet als eine Reihe von Einzel-Regeln.

• Maps und Dictionaries existieren in anonymen (statischen) und benannten Versionen.
• Die anonymen Versionen werden direkt in die Regel geschrieben und sind damit fester Bestandteil der Regel.
• Die Inhalte von anonymen Datenstrukturen können nicht zu einem späeteren Zeipunk geändert werden.
• Bei den benannten Maps und Dictionaries können die Inhalte nach dem Laden des Firewall-Regelwerkes noch angepasst werden.
• So können z.B. Programme wie fail2ban oder denyhost direkt mit der Firewall interagieren und IP-Adressen von Angreifern sperren.
• Oder eine Anti-Spam-Dienst kann das Einliefern von Spam-E-Mail über die IP-Adressen von identifizierten Spammern mittels einer Rate-Limit-Regel drosseln.

• Maps oder Data-Maps verbinden zwei Werte miteinander.
• Der Eingangswert wird in der Liste der Index-Werte der Map gesucht und der dort gespeicherte Wert wird an die Regel zurückgegeben.
• Eine Beispiel-Anwendung ist das Verzweigen auf verschiedene interne Server mit privaten Adressen per NAT, basierend auf der Port-Nummer des Dienstes:

# nft "add rule ip nat prerouting dnat" \
      "tcp dport map { 80 : 192.168.1.100, 8888 : 192.168.1.101 }"

• Verdict-Maps, auch Dictionaries genannt, verbinden einen Eingangswert des zu betrachtenen Pakets mit der Filter-Entscheidung einer Regel.
• Somit lassen sich für die verschiedenen Werte einers IP-Paketes automatisch unterschiedliche Aktionen auslösen.
• In diesem Beispiel werden die Ergebnisse einer Regel an die Quell-IPv4-Adresse des Netzwerk gebunden:

nft "add map inet filter aktion { type ipv4_addr : verdict; }"

nft "add element inet filter aktion" \
    "{ 192.0.2.80 : accept, 192.0.2.88 : drop, 192.0.2.99 : drop }"

nft "add rule inet filter input ip saddr vmap @aktion"

• Das nachfolgende nftable-Regelwerk kann als Grundlage für eine Host-Firewall für eine Linux-Workstation benutzt werden.
• Gefiltert werden die eingehenden IPv4- und IPv6-Verbindungen.
• Gängige Dienste auf einer Linux-Workstation wie Internet Printing Protocol (IPP/Cups) und Multicast-DNS werden erlaubt:

flush ruleset

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
                # nft cannot parse "param-problem" (icmpv6 type 4)
                ip6 saddr $any icmpv6 type { echo-reply, echo-request, packet-too-big, destination-unreachable, time-exceeded, 4 } accept

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

• Nachfolgend ein nftables-Regelwerk für eine einfache Firewall mit DMZ-, WAN- und LAN-Schittstelle. In der DMZ befinden sich die Server mit Web und E-Mail.
• In der Postrouting-Kette werden alle Pakete aus dem LAN-Segment, welche die Firewall in Richtung Internet (WAN) verlassen, per Masquerading-NAT auf die IPv4-Adresse der WAN-Netzwerkschnittelle umgeschrieben.

#!/usr/bin/nft -f
flush ruleset
define mgt_if = eth0
define wan_if = eth1
define lan_if = eth3
define dmz_if = eth2
define any_v6  = 0::0/0

table inet gateway-fw {
        chain forward {
                type filter hook forward priority 0
                # accept established traffic
                ct state established,related accept
                # allow all outgoing traffic from LAN
                iif $lan_if accept
                # access to services in the DMZ
                oif $dmz_if tcp dport { http, https, smtp, imap, imaps } counter accept
                # Accept essential icmpv6
                # nft cannot parse "param-problem" (icmpv6 type 4)
                ip6 saddr $any_v6 icmpv6 type { echo-reply, echo-request, packet-too-big, destination-unreachable, time-exceeded, 4 } accept
                # reject everything else
                counter log reject
       }
       chain input {
                type filter hook input priority 0
                iif lo accept
                iif $mgt_if tcp dport ssh accept
                ip6 saddr $any_v6 icmpv6 type { nd-neighbor-solicit,  nd-router-advert, nd-neighbor-advert }  accept
                ip6 saddr $any_v6 icmpv6 type { echo-reply, echo-request, packet-too-big, destination-unreachable, time-exceeded, 4 } accept
                counter log reject
       }
}
table ip nat {
        chain prerouting {
                type nat hook prerouting priority 0
        }
        chain postrouting {
                type nat hook postrouting priority 0
                oif $wan_if log masquerade
        }
}

• Derzeit gibt es für die Firewall-Infrastruktur netfilter im Linux-Kernel zwei Schnittstellen
  • das neue nftables
  • und das bekannte iptables.
• In der Zukunft, nachdem nftables zum Funktionsumfang von iptables aufgeschlossen hat, möchten die Kernel-Entwickler iptables aus dem Kernel entfernen. Dies wird aber erst in ein paar Jahren der Fall sein.
• Solange können beide Firewall-Systeme nebeneinander aktiv sein.
• Dies kann zu ungewollten Sicherheitsproblemen führen, wenn beide Firewall-Systeme aktiviert und mit wiedersprechenden Regelsätzen konfiguriert sind.
• So kann iptables Netzwerkpakete durchlassen, die nftables blocken soll.

• Das nftables Team arbeiten an einer Kompatibilitätsschicht für bestehende iptables-Scripte.
• Die Version 1.6 der iptables Kommandozeilenprogramme beinhaltet die Befehle iptables-nft, ip6tables-nft, arptables-nft und ebtables-nft.
• Diese Kommandos sind kompatibel zu den bisherigen iptables Befehlen, doch anstatt der iptables-Schnittstelle wird nftables benutzt.
• Die iptables Befehle werden dabei in den Bytecode für die nftables VM übersetzt.
• Bei Debian 10 werden bei der Installation von nftables die iptables Befehle durch die nftables Versionen ersetzt. Die original iptables Befehle sind unter dem Namen iptables-legacy zu erreichen

• Lösche mögliche alte IPTables Regeln (NAT Tabelle und Filter Tabelle)

iptables -F -t nat
iptables -F

• Installiere nftables auf der Laptop
• erstelle eine Host-Firewall auf dem Laptop in der Datei include "/etc/nftables.conf", welche nur folgende Zugriffe erlaubt
  • ICMP Echo-Request/Echo-Reply
  • Port 80 (HTTP) und 22 (SSH)
• starte einen Python-Webserver als Benutzer root auf Port 80

python -m SimpleHTTPServer 80

• Installiere nmap auf dem Laptop

apt install nmap

• Scanne per nmap nach offenen Ports vom Laptop den Laptop-Rechner Deines Nachbarn einmal mit nftables Firewall aktiv, einmal ohne eingeschaltete nftables Firewall auf dem Rechner des Nachbarn. Gibt es Unterschiede in der Ausgabe?

nmap -v -sT 192.168.1.XXX

• Teste bei eingeschalteter Firewall auf dem Rechner des Nachbarn, ob die Website/Verzeichnlis-Listing auf dem Webserver des Nachbarn vom Firefox erreichbar ist.

• starte den Python Webserver auf Port 8000

python -m SimpleHTTPServer 8000

• erstelle eine redirect oder dnat Destination-NAT Regel (Tabelle nat, Chain prerouting), welche Zugriffe auf Port 80 des Rechners auf Port 8000 umleitet: Nftables Dokumentation: man nftables
• Teste das der Firefox vom einem anderen Rechner aus auf Port 80 den Webserver erreichen kann

#!/usr/sbin/nft -f

flush ruleset

table ip filter {
        chain input {
                type filter hook input priority 0; 
		policy accept;

                iif lo accept
		
		icmp type { echo-reply, echo-request } accept
                ct state established,related accept
                tcp dport { ssh, http } ct state new accept

		counter log prefix "nftables drop: " drop
        }
}

• Regelwerk nach Änderungen neu laden

systemctl restart nftables

• aktives Regelwerk inkl. der Zähler anzeigen

nft list ruleset

• Log-Meldungen erscheinen im Syslog (/var/log/messages) und im Journal

journalctl | grep nftables
grep nftables /var/log/messages

#!/usr/sbin/nft -f

flush ruleset

table ip nat {
	chain prerouting {
		type nat hook prerouting priority 0;
		tcp dport 80 redirect to 8000
	}
	chain postrouting {
		type nat hook postrouting priority 0;
	}

}

table ip filter {
	chain input {
		type filter hook input priority 0;
		policy accept;

		iif lo accept

		icmp type { echo-reply, echo-request } accept
		ct state established,related accept
		tcp dport { ssh, http, 8000 } ct state new accept

		counter log prefix "nftables drop: " drop
	}
}

• C-Compiler installieren

yum install gcc

• der Quellcode

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <err.h>

char response[] = "HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n\r\n"
"<!DOCTYPE html><html><head><title>Bye-bye baby bye-bye</title>"
"<style>body { background-color: #111 }"
"h1 { font-size:4cm; text-align: center; color: black;"
" text-shadow: 0 0 2mm red}</style></head>"
  "<body><h1>Goodbye, world!</h1></body></html>\r\n";

int main()
{
  int one = 1, client_fd;
  struct sockaddr_in svr_addr, cli_addr;
  socklen_t sin_len = sizeof(cli_addr);

  int sock = socket(AF_INET, SOCK_STREAM, 0);
  if (sock < 0)
    err(1, "can't open socket");

  setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(int));
  int port = 8080;
  svr_addr.sin_family = AF_INET;
  svr_addr.sin_addr.s_addr = INADDR_ANY;
  svr_addr.sin_port = htons(port);

  if (bind(sock, (struct sockaddr *) &svr_addr, sizeof(svr_addr)) == -1) {
    close(sock);
    err(1, "Can't bind");
  }

  listen(sock, 5);
  while (1) {
    client_fd = accept(sock, (struct sockaddr *) &cli_addr, &sin_len);
    printf("got connection\n");

    if (client_fd == -1) {
      perror("Can't accept");
      continue;
    }

    write(client_fd, response, sizeof(response) - 1); /*-1:'\0'*/
    close(client_fd);
  }
}

• Quellcode vorbereiten

mkdir ~/src
cd ~/src
$EDITOR simple-server1.c

• Übersetzen

gcc -o simple-server simple-server1.c

• Installieren

cp simple-server /usr/local/bin

• Server starten, Testen, mit einem Web-Browser an Port 8080 verbinden

simple-server &

• SELinux Label des Dienstes anzeigen

ps -eZ | grep simple
ls -lZ /usr/local/bin/simple-server

• SELinux Policy Modul erstellen

mkdir ~/selinux-src
cd ~/selinux-src

• ein Basis SELinux Policy Modul erstellen

sepolicy generate -n simple-server --init /usr/local/bin/simple-server

• die erstellen Policy-Dateien anschauen

less simple-server.te
less simple-server.fc
less simple-server.if

• SELinux Policy compilieren und ein RPM-Paket erstellen

yum -y install rpm-build
sh simple-server.sh
ls -l

• neues Modul aktivieren

semodule -i simple-server.pp

• den vorher gestarteten simple-server Prozess stoppen

pkill simple-server

• eine SystemD Service-Unit für den Server Dienst erstellen

$EDITOR /etc/systemd/system/simple-server.service

• die Unit-Datei

[Unit]
Description=a simple http server
After=syslog.target network.target

[Service]
ExecStart=/usr/local/bin/simple-server

[Install]
WantedBy=multi-user.target

• neue Systemd-Service-Datei mit dem richtigen SELinux Label versehen

restorecon -R -v /etc/systemd/system/simple-server.service

• Systemd Service-Units neu laden und den Simple-Server starten

systemctl daemon-reload
systemctl start simple-server
systemctl enable simple-server

• Nun den Dienst benutzen. Das Modul ist noch im Permissive Mode, Verstösse gegen die Policy werden im Audit-Log protokolliert

ausearch -m avc -ts recent -c simple-server

• Erklärungen zu den Policy-Fehlermeldungen

ausearch -m avc -ts today -c simple-server | audit2why  | less

• Policy-Regeln aus den Audit-Meldungen erstellen

sepolgen-ifgen
ausearch -m avc -ts today -c simple-server | audit2allow -R
require {
        type simple-server_t;
        class tcp_socket { bind create setopt accept listen };
}

#============= simple-server_t ==============
allow simple-server_t self:tcp_socket { bind create setopt accept listen };
corenet_tcp_bind_generic_node(simple-server_t)
corenet_tcp_bind_http_cache_port(simple-server_t)

• Neue Policy-Regeln in die Policy einfügen (Datei simple-server.te), Modul entfernen, neu kompilieren und dann neu laden

semodule -r simple-server
sh ./simple-server.sh
semodule -i simple-server.pp
systemctl restart simple-server

• Unser Server lernt Logging. Den Inhalt in eine Datei simple-server.patch in das Verzeichnis mit dem Quellcode des simple-server speichern:

--- simple-server1.c    2016-08-24 20:12:56.379000000 +0000
+++ simple-server2.c    2016-08-24 21:13:31.648000000 +0000
@@ -15,13 +15,20 @@
 "h1 { font-size:4cm; text-align: center; color: black;"
 " text-shadow: 0 0 2mm red}</style></head>"
   "<body><h1>Goodbye, world!</h1></body></html>\r\n";
-
+
 int main()
 {
   int one = 1, client_fd;
+  FILE *f = fopen("/var/log/simple-server.log", "a");
+  if (f == NULL)
+  {
+      printf("Error opening file!\n");
+      exit(1);
+  }
+
   struct sockaddr_in svr_addr, cli_addr;
   socklen_t sin_len = sizeof(cli_addr);
-
+
   int sock = socket(AF_INET, SOCK_STREAM, 0);
   if (sock < 0)
     err(1, "can't open socket");
@@ -41,7 +48,7 @@
   listen(sock, 5);
   while (1) {
     client_fd = accept(sock, (struct sockaddr *) &cli_addr, &sin_len);
-    printf("got connection\n");
+    fprintf(f,"got connection\n");

     if (client_fd == -1) {
       perror("Can't accept");

• Patch einspielen

patch -p1 < simple-server.patch

• das gepatchte Programm:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <err.h>

char response[] = "HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n\r\n"
"<!DOCTYPE html><html><head><title>Bye-bye baby bye-bye</title>"
"<style>body { background-color: #111 }"
"h1 { font-size:4cm; text-align: center; color: black;"
" text-shadow: 0 0 2mm red}</style></head>"
  "<body><h1>Goodbye, world!</h1></body></html>\r\n";

int main()
{
  int one = 1, client_fd;
  struct sockaddr_in svr_addr, cli_addr;
  socklen_t sin_len = sizeof(cli_addr);

  int sock = socket(AF_INET, SOCK_STREAM, 0);
  if (sock < 0)
    err(1, "can't open socket");

  setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(int));
  int port = 8080;
  svr_addr.sin_family = AF_INET;
  svr_addr.sin_addr.s_addr = INADDR_ANY;
  svr_addr.sin_port = htons(port);

  if (bind(sock, (struct sockaddr *) &svr_addr, sizeof(svr_addr)) == -1) {
    close(sock);
    err(1, "Can't bind");
  }

  FILE *f = fopen("/var/log/simple-server.log", "a");
  if (f == NULL)
  {
      printf("Error opening file!\n");
      exit(1);
  }

  listen(sock, 5);
  while (1) {
    client_fd = accept(sock, (struct sockaddr *) &cli_addr, &sin_len);
    fprintf(f,"got connection\n");
    fflush(f);

    if (client_fd == -1) {
      perror("Can't accept");
      continue;
    }

    write(client_fd, response, sizeof(response) - 1); /*-1:'\0'*/
    shutdown(client_fd,2);
    close(client_fd);
  }
}

• den neuen Server-Dienst übersetzen, alten simple-server stoppen, neue Programm-Datei nach /usr/local/bin kopieren, SELinux Label anpassen und den Dienst neu starten

gcc -o simple-server simple-server2.c
systemctl stop simple-server
cp simple-server /usr/local/bin
restorecon -R -v /usr/local/bin/simple-server
systemctl start simple-server

• per Web-Browser die Webseite auf http://localhost:8080/ aufrufen
• neue SELinux Log-Meldungen tauchen auf

# ausearch -m avc -ts recent
----
time->Wed Aug 24 21:17:34 2016
type=SYSCALL msg=audit(1472073454.717:1390): arch=c000003e syscall=2 success=yes exit=3 a0=400ae2 a1=441 a2=1b6 a3=21000 items=0 ppid=1 pid=7869 auid=4294967295 uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=(none) ses=4294967295 comm="simple-server" exe="/usr/local/bin/simple-server" subj=system_u:system_r:simple-server_t:s0 key=(null)
type=AVC msg=audit(1472073454.717:1390): avc:  denied  { open } for  pid=7869 comm="simple-server" path="/var/log/simple-server.log" dev="vda1" ino=268256 scontext=system_u:system_r:simple-server_t:s0 tcontext=system_u:object_r:var_log_t:s0 tclass=file
type=AVC msg=audit(1472073454.717:1390): avc:  denied  { create } for  pid=7869 comm="simple-server" name="simple-server.log" scontext=system_u:system_r:simple-server_t:s0 tcontext=system_u:object_r:var_log_t:s0 tclass=file
type=AVC msg=audit(1472073454.717:1390): avc:  denied  { add_name } for  pid=7869 comm="simple-server" name="simple-server.log" scontext=system_u:system_r:simple-server_t:s0 tcontext=system_u:object_r:var_log_t:s0 tclass=dir
type=AVC msg=audit(1472073454.717:1390): avc:  denied  { write } for  pid=7869 comm="simple-server" name="log" dev="vda1" ino=258603 scontext=system_u:system_r:simple-server_t:s0 tcontext=system_u:object_r:var_log_t:s0 tclass=dir

• Policy-Erweiterung ausgeben, prüfen und in die Type-Enforcement-Datei simple-server.te einfügen:

# ausearch -m avc -ts recent -c simple-server | audit2allow -R

require {
        type var_log_t;
        type simple-server_t;
        class file { create open };
}

#============= simple-server_t ==============
allow simple-server_t var_log_t:file { create open };

• simple-server SELinux Modul entfernen, Policy neu übersetzen, Modul neu laden, testen
• Solange die Policy anpassen, bis keine Permission-Meldungen im Audit-Log erscheinen
• "Permissive" aus der finalen Policy herausnehmen

# less simple-server.te
policy_module(simple-server, 1.0.0)

########################################
#
# Declarations
#

type simple-server_t;
type simple-server_exec_t;
init_daemon_domain(simple-server_t, simple-server_exec_t)

#permissive simple-server_t;

########################################
#
# simple-server local policy
#
require {
        type simple-server_t;
        type var_log_t;
        class tcp_socket { bind create setopt accept listen shutdown write };
        class file { create open write };
        class dir { write add_name };
}

allow simple-server_t self:fifo_file rw_fifo_file_perms;
allow simple-server_t self:unix_stream_socket create_stream_socket_perms;
allow simple-server_t self:tcp_socket { bind create setopt accept listen shutdown write };
allow simple-server_t var_log_t:file { create open write };
allow simple-server_t var_log_t:dir { write add_name };

corenet_tcp_bind_generic_node(simple-server_t)
corenet_tcp_bind_http_cache_port(simple-server_t)
domain_use_interactive_fds(simple-server_t)
logging_manage_generic_logs(simple-server_t)
logging_rw_generic_log_dirs(simple-server_t)

• simple-server SELinux Modul laden, simple-server Prozess per SystemD neu starten, Programm testen

• ACHTUNG: unter Debian 9 nicht die Boot-Partition mit ext4-Verschlüsselung betreiben. Der von Debian 9 benutzte Boot-Loader GRUB2 kann noch nicht von ext4 Dateisystemen mit Verschlüsselung booten
  • https://lwn.net/Articles/639427/
  • Installation der Linux Key-Utilities:

    apt install keyutils
    

  • Platz schaffen: die Swap-Partition abhängen, löschen, im verbleibenen Platz 2 neue Partitionen mit je 1 GB erstellen. Den verbleibenden Rest als Partition 5 für den Swap-Space einrichten. UUID in der Datei /etc/fstab anpassen und dann wieder als Swap-Partition einhängen

    swapoff /dev/sda3
    parted
    parted> p
    parted> rm <id-der-swap-partition>
    parted> mkpart part1 ext4 <start> <end>
    parted> mkpart part2 ext4 <start> <end>
    parted> mkpart swap ext4 <start> 100%
    parted> quit
    mkswap /dev/sda5
    swapon /dev/sda5
    

  • Die Partition /dev/sda3 mit ext4 formatieren (mit 4096 Byte Blöcken!)

    mkfs.ext4 -b 4096 /dev/sda3
    

  • Die ext4 Funktion "Verschlüsselung" im Dateisystem auf /dev/sda3 anschalten

    tune2fs -O encrypt /dev/sda3
    

  • Partition /dev/sda3 unter /encrypted einhängen

    mkdir /encrypted
    mount /dev/sda3 /encrypted
    

  • einen neuen Schlüssel dem Linux-Session-Keyring hinzufügen und dem Verzeichnis /encrypted zuordnen

    mkdir /encrypted/test
    e4crypt add_key /encrypted/test
    keyctl show
    e4crypt set_policy <key-id> /encrypted/test
    

  • Daten in das verschlüsselte Verzeichnis kopieren

    cp /etc/passwd /encrypted/test
    lsattr /encrypted/test
    

  • Verschieben auf dem gleichen Dateisystem in ein verschlüsseltes Verzeichnis geht nicht, die Dateien müssen neu angelegt werden!

    cp /etc/hosts.deny /encrypted
    mv /encrypted/hosts.deny /encrypted/test
    

• LUKS Tools und LVM installieren

apt install cryptsetup lvm2

• neues Physisches Volume in /dev/sda4 erstellen

pvcreate /dev/sda4
vgcreate crypt_vg /dev/sda4

• ein neues logisches Volume im LVM erstellen (in der Volumegroup crypt_vg):

lvcreate --size 500M --name crypt crypt_vg

• ein verschlüsseltes Laufwerk auf dem LV erstellen

cryptsetup --verbose --verify-passphrase luksFormat \
    /dev/mapper/crypt_vg-crypt

• das verschlüsselte Laufwerk im Linux-Device-Mapper anmelden

cryptsetup luksOpen /dev/mapper/crypt_vg-crypt crypt

• an dieser Stelle muss das neue Laufwerk nun im Device-Mapper auftauchen

ls -l /dev/mapper/crypt

• Das 'crypt' Laufwerk formatieren (hier ext4, andere Dateisysteme und SWAP sind möglich)

mkfs.ext4 /dev/mapper/crypt

• leeres Verzeichnis anlegen und das neue Dateisystem dort mounten:

mkdir /crypt
mount /dev/mapper/crypt /crypt

• Konfigurationsdatei für verschlüsselte Laufwerke anlegen

$EDITOR /etc/crypttab

• Eintrag für unser verschlüsseltes Laufwerk

crypt /dev/mapper/crypt_vg-crypt  none luks,timeout=180

• Eintrag in der /etc/fstab

/dev/mapper/crypt     /crypt    ext4    defaults  0 0

• Partition in der /etc/fstab eintragen, Reboot testen

• ClamAV installieren

apt install clamav clamav-daemon clamav-base clamav-freshclam

• ist SELinux aktiviert (z.B. CentOS/Red Hat), muss einen Antivirus-Scan im SELinux zulassen werden

setsebool -P antivirus_can_scan_system 1
setsebool -P clamd_use_jit on

• FreshClam Konfiguration pruefen, Option DatabaseMirror von db.local.clamav.net auf db.de.clamav.net ändern, dann den FreshClam Dienst neu starten

$EDITOR /etc/clamav/freshclam.conf
systemctl restart clamav-freshclam

• Im Journal nach Meldungen schauen

journalctl -u clamav-freshclam

• Wurde FreshClam ohne Fehler gestartet?

systemctl status clamav-freshclam

• Beispiel: Virensignaturen erfolgreich geladen

[root@notebook33 src]# systemctl status clamav-freshclam
freshclam.service - freshclam update ClamAV databases
   Loaded: loaded (/etc/systemd/system/freshclam.service; enabled)
   Active: inactive (dead) since Wed 2015-11-25 14:59:35 CET; 1min 2s ago
  Process: 28088 ExecStart=/usr/bin/freshclam -c 12 (code=exited, status=0/SUCCESS)
 Main PID: 28088 (code=exited, status=0/SUCCESS)

Nov 25 14:59:20 notebook33 freshclam[28088]: Downloading daily.cvd [100%]
Nov 25 14:59:21 notebook33 freshclam[28088]: [440B blob data]
Nov 25 14:59:29 notebook33 freshclam[28088]: daily.cvd updated (version: 21096, sigs: 1700789, f-level: 63, builder: neo)
Nov 25 14:59:29 notebook33 freshclam[28088]: daily.cvd updated (version: 21096, sigs: 1700789, f-level: 63, builder: neo)
Nov 25 14:59:29 notebook33 freshclam[28088]: [293B blob data]
Nov 25 14:59:29 notebook33 freshclam[28088]: Downloading bytecode.cvd [100%]
Nov 25 14:59:30 notebook33 freshclam[28088]: bytecode.cvd updated (version: 270, sigs: 46, f-level: 63, builder: shurley)
Nov 25 14:59:30 notebook33 freshclam[28088]: bytecode.cvd updated (version: 270, sigs: 46, f-level: 63, builder: shurley)
Nov 25 14:59:35 notebook33 freshclam[28088]: Database updated (4125060 signatures) from database.clamav.net (IP: 62.201.161.84)
Nov 25 14:59:35 notebook33 freshclam[28088]: Database updated (4125060 signatures) from database.clamav.net (IP: 62.201.161.84)

• ClamAV Konfiguration prüfen

  clamconf | less
  

• Manueller Scan (im Vordergrund)

clamscan -vr /usr

• EICAR Test-Virus in einem Heimverzeichnis erstellen, Heimverzeichnisse scannen (per Clam-Daemon)

echo -n 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*' \
        > /home/nutzerXX/eicar.com
clamdscan -vr /home

• ClamAV Daemon starten

  systemctl start clamav-daemon
  

• Clam-Daemon Auslastung überwachen

  clamdtop
  

• auf Virenfunde reagieren, in der Datei /etc/clamav/virusevent.d/ ein Shellskript anlegen

  #!/bin/sh
  logger -t virus "Signature detected: $CLAM_VIRUSEVENT_VIRUSNAME in $CLAM_VIRUSEVENT_FILENAME"
  

• Shell Skript ausführbar machen
• und in der Datei /etc/clamav/clamd.conf eintragen

  VirusEvent /etc/clamav/virusevent.d/log-virus
  

• Cryptographic competitions http://competitions.cr.yp.to/
• NIST SHA3 Competition http://csrc.nist.gov/groups/ST/hash/sha-3/
• NIST AES Competition http://csrc.nist.gov/archive/aes/index2.html
• NIST - Announcing Request for Nominations for Public-Key Post-Quantum Cryptographic Algorithms: https://www.federalregister.gov/documents/2016/12/20/2016-30615/announcing-request-for-nominations-for-public-key-post-quantum-cryptographic-algorithms

• Kernel 5.4: random: try to actively add entropy rather than passively wait for it https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=50ee7529ec45
• LWN- "Waiting for entropy" https://lwn.net/Articles/724643/
• PEP 524: os.urandom() now blocks on Linux in Python 3.6 https://haypo.github.io/pep-524-os-urandom-blocking.html
• Weak Keys Remain Widespread in Network Devices https://www.cis.upenn.edu/~nadiah/papers/weak-keys/weak-keys.pdf