Debian-Linux Server Sicherheit Kursnotizen August 2021

• 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/11.0.0/amd64/iso-cd/debian-10.1.0-amd64-netinst.iso

• SHA256 Fingerabdruck der Datei errechnen

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

• Datei mit den Hash-Prüfsummen laden

wget https://debian.inf.tu-dresden.de/debian-cd/11.0.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/11.0.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

• Debian Pakete sind über eine Signatur-Kette geschützt (anders als RPM Pakete bei RedHat/CentOS/Fedora, welche direkt durch eine GPG-Signatur geschützt sind)
• Die Hash-Prüfsummen der Debian-Pakete sind in den Paketlisten-Dateien hinterlegt (z.B. main/Contents-amd64). Die Hash-Prüfsummen der Paketlisten sind in der Release Datei hinterlegt, und diese Datei ist mit den GPG-Schlüssel des Debian-Release-Teams unterschrieben.
• Um nun ein beliebiges Debian-Paket zu prüfen
  • errechne die SHA256 Prüfsumme des Pakets
  • vergleiche diese Prüfsumme mit der Prüfsumme in der Paketliste der Architektur
  • Errechne die SHA256-Prüfsumme der Paketlisten Datei.

  wget https://debian.inf.tu-dresden.de/debian/dists/Debian11.0/main/binary-amd64/Packages.gz
  openssl dgst -sha256 < Packages.gz
  zcat Packages.gz | less
  

  • Lade die aktuelle Release-Datei für die Debian-Version:

  $ wget https://debian.inf.tu-dresden.de/debian/dists/Debian11.0/Release
  $ wget https://debian.inf.tu-dresden.de/debian/dists/Debian11.0/Release.gpg
  

  • Importiere die (öffentlichen) GPG-Schlüssel des Debian-Release Teams. Hat man keine (vertrauenswürdige Debian-Installation), so findet man die Schlüssel unter https://ftp-master.debian.org/keys.html

  $ gpg --import /etc/apt/trusted.gpg.d/debian-archive-*
  

  • Als letzter Schritt werden die Signaturen auf der Release-Datei geprüft

  gpg --verify Release.gpg Release
  

  • Alle Schritte dieser Prüfung müssen erfolgreich abgeschlossen sein, um der Installationsdatei (DEB-Paket) vertrauen zu können. Diese Prüfung wird von den Debian-Paketmanager-Programmen (apt, apt-get, aptitude, debootstrap) automatisch durchgeführt.

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

• Yescrypt ist eine neue Schlüsselableitungsfunktion für Passwörter vom OpenWall Projekt. Es basiert auf scrypt (RFC 7914) von Colin Percival (früherer Sicherheitleiter des FreeBSD Projektes). Es schützt besser vor Brute-Force Angriffen als SHA512 und andere Schlüsselableitungsfunktionen.
  • Debian 11 setzt Yescrypt als Standard-Algorithmus für die Benutzerpasswörter ein
  • Bei einem Update von Debian 10 auf Debian 11 bleiben die Passwort-Hashes im SHA512 Format
    • erst bei einer Passwortänderung mittels passwd wir der neue Yescrypt-Hash erzeugt
  • Beispiel Debian 10 SHA512 Hash in der /etc/shadow

  nutzer:$6$NtILOHbh$SZ1pFZKkJj/xqtrxqtSBrkOgRWQmXfv4tJhwlCfNkL7V4ft8G6eyLkVhxmvAs6DQsPuAmRqB7WVfJHMB5w0340:16442:0:99999:7:::
  

  • Beispiel Debian 11 Yescrypt Hash in der /etc/shadow

  nutzer:$y$j9T$YhVeKuFhMSSA91rR4FhwT/$9YTuWLhjyf1oqcPMoEkJFqSL.6YMRMQVMGaIgWIJyq9:18868:0:99999:7:::
  

  • Yescrypt in Debian 11 https://www.debian.org/releases/bullseye/amd64/release-notes/ch-information.en.html#pam-default-password
  • Yescrypt Informationen https://www.openwall.com/yescrypt/

• 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

• PAM Duress (https://github.com/nuvious/pam-duress) ist ein interessantes PM-Modul welches es dem Benutzer erlaubt, alternative Passwörter im PAM zu hinterlegen. Diese Passwörter sind jeweils mit einen Shell-Skript verbunden. Wird eines der "Duress" Passwörter statt dem "normalen" Benutzerpasswort eingegeben, so wird das dazugehörige Script ausgeführt.
• Beschreibung der Einsatzszenatrien von der Projekt-Webseite

  Diese Funktion könnte genutzt werden, um jemandem, der unter [Zwang] zur Eingabe eines Kennworts gezwungen wird, die Möglichkeit zu geben, ein Kennwort einzugeben, das den Zugang gewährt, aber im Hintergrund Skripte ausführt, um sensible Daten zu bereinigen, Verbindungen zu anderen Netzwerken zu schließen, um lateral movement einzuschränken, und/oder eine Benachrichtigung oder einen Alarm zu senden (möglicherweise mit detaillierten Informationen wie Standort, sichtbaren WLAN-Hotspots, einem Bild von der Kamera, einem Link zu einem Stream vom Mikrofon usw.). Es kann sogar einen Prozess starten, um das Modul pam_duress zu entfernen, damit der Bedrohungsakteur nicht sehen kann, ob das PAM-Duress verfügbar war.

• Weitere Einsatzgeniete:
  • Wegwerfbare Gast-Zugänge einrichten
  • Automatisches mit-protokollieren einer Sitzung per "sudo" beim Login einschalten
  • MacOS "Find-my-Mac" nachbauen (gestohlene Rechner orten)

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

visudo -f /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

visudo -f /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
systemd-run --on-active=20 -p CPUQuota=50% stress-ng --cpu 4

$EDITOR /etc/systemd/system.conf
-----
DefaultCPUAccounting=yes
DefaultIOAccounting=yes
DefaultBlockIOAccounting=yes
DefaultMemoryAccounting=yes
DefaultTasksAccounting=yes

systemctl set-property --runtime cups.service CPUQuota=10%
systemctl cat cups.service

• 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
• ProtectSystem={ full | strict }
• ProtectHome=

ssh-keygen -H -f .ssh/known_hosts

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

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

• 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

• OpenSSH hat in früherern Versionen standardmässig Schlüssel mit dem RSA-SHA1 Algorithmus erzeugt. Dieser Algorithmus gilt inzwischen als unsicher und werden bald mit einer neuen Version von OpenSSH nicht mehr unterstützt
  • Daher sollten Benutzer von OpenSSH testen, ob sie noch RSA-SHA1 Schlüssel benutzen und diese ggf. durch neue Schlüssel austauschen
  • Test mit RSA-SHA1 abgeschaltet. Klappt die Anmeldung, so wird ein anderer Schlüssel benutzt. Schlägt die Anmeldung fehlt, so sollte ein neuer Schlüssel für diesen Benutzer erstellt werden:

    ssh -oHostKeyAlgorithms=-ssh-rsa user@host
    

  • Gibt es die folgende Fehlermeldung, dann benutzt der Server noch alte RSA-SHA1 Schlüssel und diese Schlüssel sind in der lokalen known-hosts Datei eingetragen:

    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
    @    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
    IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
    Someone could be eavesdropping on you right now (man-in-the-middle attack)!
    It is also possible that a host key has just been changed.
    The fingerprint for the ECDSA key sent by the remote host is
    SHA256:/7MPZYXQhPQ0uwZaupxxUC0EDU7I2D+s8OQCLtN69rE.
    Please contact your system administrator.
    Add correct host key in /home/nutzer/.ssh/known_hosts to get rid of this message.
    Offending RSA key in /home/nutzer/.ssh/known_hosts:157
    ECDSA host key for ssh-host.example.com has changed and you have requested strict checking.
    Host key verification failed.
    

  • Der Server-Betreiber sollte den alten RSA-SHA1 Schlüssel vom Server entfernen
  • Der Benutzer sollte den Hash-Eintrag des RSA-SHA1 aus der Datei known-hosts entfernen und dann den Hash des neuen Schlüssels mit dem Betreiber des Servers (oder via DNS, siehe unten) abgleichen
• Empfohlene SSH Schlüssel-Algorithmen
  • RFC 8332 - RSA SHA-2 signature algorithms rsa-sha2-256/512.
  • RFC 5656 - Elliptic Curve Algorithm Integration in the Secure Shell Transport Layer (ecdsa-sha2-nistp256/384/521)
  • RFC 8709 - Ed25519 and Ed448 Public Key Algorithms for the Secure Shell (SSH) Protocol
• Informationen: OpenSSH 8.3 released (and ssh-rsa deprecation notice)

• 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

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

• 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

• 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

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

• 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

• 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.mnus.de/2019/11/announcing-sshign/

https://github.com/jschauma/jass

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

• BCC ist die BPF Compiler Collection, eine Sammlung von Tools und eBPF Programmen

  

• BCC Programme sind abhängig von der jeweiligen Kernel-Version und müssen daher auf der Maschine mit Hilfe der aktuellen Kernel-Header kompiliert werden. Das Kompilieren geschied im Hintergrund beim Aufruf des Wrapper-Scripts.

# apt install bpfcc-tools bpfcc-lua bpftrace python3-bpfcc
# apt install linux-headers-$(uname -r)

• Unter Debian enden alle BCC Programme auf -bpfcc:

  # ls -l /usr/sbin/*bpfcc
  -rwxr-xr-x 1 root root 34536 Feb  4  2019 /usr/sbin/argdist-bpfcc
  -rwxr-xr-x 1 root root  1648 Feb  4  2019 /usr/sbin/bashreadline-bpfcc
  -rwxr-xr-x 1 root root  4231 Feb  4  2019 /usr/sbin/biolatency-bpfcc
  -rwxr-xr-x 1 root root  5066 Feb  4  2019 /usr/sbin/biosnoop-bpfcc
  -rwxr-xr-x 1 root root  6387 Feb  4  2019 /usr/sbin/biotop-bpfcc
  -rwxr-xr-x 1 root root  1721 Feb  4  2019 /usr/sbin/bitesize-bpfcc
  -rwxr-xr-x 1 root root  2453 Feb  4  2019 /usr/sbin/bpflist-bpfcc
  -rwxr-xr-x 1 root root  6339 Feb  4  2019 /usr/sbin/btrfsdist-bpfcc
  -rwxr-xr-x 1 root root 10101 Feb  4  2019 /usr/sbin/btrfsslower-bpfcc
  -rwxr-xr-x 1 root root  4674 Feb  4  2019 /usr/sbin/cachestat-bpfcc
  [...]
  

• Im folgenden werden einige BCC Tools vorgestellt, welche für die Sicherheit von Linux-Servern interessant sind

• bpftrace ist eine kleine Programmiersprache (ähnlich wie awk), die es Administratoren ermöglicht, kleine eBPF Programme zu schreiben, welche auf eBPF Ereignisse reagieren
  • Homepage https://bpftrace.org/
  • Github Source Repository https://github.com/iovisor/bpftrace
• Histogram-Daten werden nach dem Beenden des Script mit CTRL+C ausgegeben
• Unter Debian liegen die mitgelieferten bpftrace Programme unterhalb von /usr/sbin/ und haben die Dateiendung .bt (für bpftrace)

# ls /usr/sbin/*.bt
/usr/sbin/bashreadline.bt  /usr/sbin/execsnoop.bt       /usr/sbin/pidpersec.bt  /usr/sbin/tcpconnect.bt
/usr/sbin/biolatency.bt    /usr/sbin/gethostlatency.bt  /usr/sbin/runqlat.bt    /usr/sbin/tcpdrop.bt
/usr/sbin/biosnoop.bt      /usr/sbin/killsnoop.bt       /usr/sbin/runqlen.bt    /usr/sbin/tcpretrans.bt
/usr/sbin/bitesize.bt      /usr/sbin/loads.bt           /usr/sbin/statsnoop.bt  /usr/sbin/vfscount.bt
/usr/sbin/capable.bt       /usr/sbin/mdflush.bt         /usr/sbin/syncsnoop.bt  /usr/sbin/vfsstat.bt
/usr/sbin/cpuwalk.bt       /usr/sbin/oomkill.bt         /usr/sbin/syscount.bt   /usr/sbin/writeback.bt
/usr/sbin/dcsnoop.bt       /usr/sbin/opensnoop.bt       /usr/sbin/tcpaccept.bt  /usr/sbin/xfsdist.bt

• Beispiel eines bpftrace Scriptes

# cat /usr/sbin/syscount.bt
#!/usr/bin/env bpftrace
/*
 * syscount.bt  Count system callls.
 *              For Linux, uses bpftrace, eBPF.
 *
 * This is a bpftrace version of the bcc tool of the same name.
 * The bcc versions translates syscall IDs to their names, and this version
 * currently does not. Syscall IDs can be listed by "ausyscall --dump".
 *
 * Copyright 2018 Netflix, Inc.
 * Licensed under the Apache License, Version 2.0 (the "License")
 *
 * 13-Sep-2018  Brendan Gregg   Created this.
 */

BEGIN
{
        printf("Counting syscalls... Hit Ctrl-C to end.\n");
        // ausyscall --dump | awk 'NR > 1 { printf("\t@sysname[%d] = \"%s\";\n", $1, $2); }'
}

tracepoint:raw_syscalls:sys_enter
{
        @syscall[args->id] = count();
        @process[comm] = count();
}

END
{
        printf("\nTop 10 syscalls IDs:\n");
        print(@syscall, 10);
        clear(@syscall);

        printf("\nTop 10 processes:\n");
        print(@process, 10);
        clear(@process);
}

• A brief introduction to XDP and eBPF https://blogs.igalia.com/dpino/2019/01/07/a-brief-introduction-to-xdp-and-ebpf/
• A curated list of awesome projects related to eBPF: https://github.com/zoidbergwill/awesome-ebpf
• BPF, eBPF, XDP and Bpfilter… What are These Things and What do They Mean for the Enterprise? https://www.netronome.com/blog/bpf-ebpf-xdp-and-bpfilter-what-are-these-things-and-what-do-they-mean-enterprise/
• BCC Tutorial https://github.com/iovisor/bcc/blob/master/docs/tutorial.md
• Learn eBPF Tracing: Tutorial and Examples http://www.brendangregg.com/blog/2019-01-01/learn-ebpf-tracing.html
• Network debugging with eBPF (RHEL 8) https://developers.redhat.com/blog/2018/12/03/network-debugging-with-ebpf/
• Using eBPF for network traffic analysis https://www.ntop.org/wp-content/uploads/2018/10/Sabella.pdf
• BCC Referenz: https://github.com/iovisor/bcc/blob/master/docs/reference_guide.md
• eBPF Summit 2021:
  • Tag 1: https://www.youtube.com/watch?v=Kp3PHPuFkaA
  • Tag 2: https://www.youtube.com/watch?v=ZNtVedFsD-k
• eBPF Foundation https://ebpf.io/
• Comparing SystemTap and bpftrace https://lwn.net/Articles/852112/
• nsjail | A light-weight process isolation tool, making use of Linux namespaces and seccomp-bpf syscall filters (with help of the kafel bpf language)
• How io_uring and eBPF Will Revolutionize Programming in Linux – The New Stack
• Auch in eBPF kann es Sicherheits-Fehler geben Zero Day Initiative — CVE-2020-8835: Linux Kernel Privilege Escalation via Improper eBPF Program Verification

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

# 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 Container Konfiguration anzeigen -> siehe Go Template wie man nach Konfiguration-Informationen filtern kann 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-Ausgaben können mittels eigener log drivers auf andere Ziele umgelenkt werden(json-file, syslog, none, …)

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

• Ein Docker Image aus einem Dockerfile (Docker-Image Bauanleitung) erstellen

mkdir -p docker-work
cd docker-work
$EDITOR 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://<ip-der-VM>:<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
  • erstelle einen neuen NGINX Container (auf Basis des NGINX Dockerfiles oben in der Anleitung), 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

• 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

• 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

• das mbox Programm bietet eine einfache, simple sandbox mittels CGroups und Namespaces. mbox kann benutzt werden um die Ausführung von unbekannten Programmen (Scripts, Binärprogramme) einzuschränken und zu überwachen https://github.com/tsgates/mbox

• https://github.com/omegaup/minijail
• https://lwn.net/Articles/700557/

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

• 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

# cat /sys/kernel/security/lsm
lockdown,capability,yama,tomoyo,bpf

• 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

• LoadPin ist seit Kernel 4.7 Bestandteil von Linux
• LoadPin gewährleistet das alle Kernel-Daten (Module, Firmware-Blobs etc) vom gleichen, read-only Datei-System gelesen werden.
• LoadPin verhindert Angriffe auf den Kernel durch bösartige Kernel-Module (z.B. Root-Kits)
• Dokumentation: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/admin-guide/LSM/LoadPin.rst

• Das SafeSetID Modul überwacht die Benutzung der SetUID/SetGID Syscalls (UID oder GID eines Prozesses ändern, z.B. via su oder sudo oder per SetUID-Bit in den Dateisystemrechten) und prüft die Benutztung gegen eine systemweite Whitelist
  • Mittels SafeSetID können Prozesse die Capability CAP_SETUID/CAP_SETGID benutzen um von einem unpriviligierten Benutzeraccount in einen anderen zu wechseln (um Rechte abzugeben), ohne das diese Programme die Rechte ausweiten können oder sogar Root- Rechte erlangen können
  • Die Whitelist wird als Text-Datei mit je einer Regel pro Zeile in das securityfs Pseudo-Dateisystem unter dem Pfad safesetid/uid_allowlist_policy (für UID Übergänge) und safesetid/gid_allowlist_policy (für GID Übergänge) geschrieben
  • Das Format jedes Eintrages ist <ausgangs-UID>:<neue-UID>\n
• Dokumentation: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/admin-guide/LSM/SafeSetID.rst

• Das Lockdown Modul beschränkt bestimmte Funktionen des Linux Kernels (Laden von unsignierten Modulen, PTRACE, eBPF, Hibernation = Speicherinhalte auf Datenträger schreiben, Zugriffe auf spezielle Gerätedateien unter /dev, Kernel perf Schnittstellen, ACPI-Tabellen …)
  • Lockdown kann per Kernel-Commandozeile aktiviert werden: Parameter lockdown=
  • Nachträglich kann Lockdown über das Pseudo-Dateisystem unter /sys/kernel/security/lockdown ein- oder aus-geschaltet werden
  • Lockdown kennt zwei Modi
    • integrity - Funktionen sind ausgeschaltet, welche den laufenden Kernel verändern können
    • confidentiality - Funktionen sind ausgeschaltet über welche sensible Daten aus dem Kernel ausgelesen werden können (z.B. Zugriffe auf /dev/mem
• Lockdown LSM ist seit Kernel 5.4 verfügbar
• Lockdown Status ausgeben (hier none, Modi integrity und confidentiality sind möglich)

  # cat /sys/kernel/security/lockdown
  [none] integrity confidentiality
  

• Links
  • Lockdown as a security module
  • Linux kernel lockdown, integrity, and confidentiality

• Landlock ist ein LSM welches Prozessen erlaubt, die eigenen Dateisystem-Rechte (und die Rechte von Kind-Prozessen) über die Unix-Dateisystemrechte hinaus einzuschränken.
  • Da die Landlock Rechte-Einschränkungen vererbt werden, können auch Supervisor Programme erstellt werden, um Kind-Prozesse zu beschränken, ohne diese Kind-Prozesse im Quellcode ändern zu müssen
  • Landlock ist von der Idee vergleichbar mit dem OpenBSD pledge Mechanismus, wirkt jedoch nur auf Dateisystemrechte (pledge wirkt auf verschiedenen Syscall-Gruppen)
• Seit Kernel 5.13 verfügbar
• Dokumentation: https://landlock.io/
• Kernel Dokumentation: https://www.kernel.org/doc/html/latest/security/landlock.html

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

• SELinux Hilfspakete installieren

yum install policycoreutils setools libselinux-utils selinux-policy-doc setools-console
  \ policycoreutils-python3 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

• TOMOYO LSM kann zur Analyse eines Linux-Systems, oder zur Implementation einer Sicherheitrichtlinie für das Linux-System verwendet werden
• TOMOYO beschränkt Linux-Prozesse auf Basis des Dateisystem-Pfads und der Prozess-Hierarchy ("Domain" in der TOMOYO Terminology, hat aber keinen Zusammenhang mit DNS, dem Domain-Name-System)
• TOMOYO fasst einen oder mehrere Prozesse zu einer Domain zusammen
  • Jede Domain wird über ein Profil reglementiert
  • Es können 255 unterschiedliche Profile im TOMOYO LSM definiert werden
  • Jedes Profil kann unabhängig von anderen Profilen in einem von 3 Modi verwendet werden
    • Learning: Syscall-Aufrufe und Dateisystem-Interaktionen werden protokolliert und in das Profil aufgenommen (Erstellung eines Baseline-Profils für eine Prozess-Gruppe/Domain)
    • Permissive: Verstösse gegen die Policy werden protokolliert, aber nicht durchgesetzt
    • Enforcing: Verstösse gegen die Policy werden aktiv verhindert und protokolliert
• Kernel-Dokumentation: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/admin-guide/LSM/tomoyo.rst
• Handbuch: https://tomoyo.osdn.jp/2.6/index.html.en
• TOMOYO kann alternativ auch als Linux-Kernel-Modul geladen werden (dann ist es kein LSM, sondern kann zusätzlich zu anderen Major-LSMs benutzt werden)

• SMACK ist ein Mandatory Access Controll System im Linux Kernel, welches im Vergleich zu SELinux weniger komplex ist
• SMACK ist seit Kernel 2.6.25 Teil des Linux-Kernels
• SMACK wird heute hauptsächlich in Linux-Systemen von IoT-Geräten und in Automotive-Anwendungen verwendet (z.B. im Tizen OS von Samsung)
  • Wie auch SELinux arbeitet SMACK auch mit Sicherheits-Label auf Basis von erweiterten Attributen in den Linux-Dateisystemen
    • Es ist möglich SMACK in mittels der eingebauten Sicherheitspolicy auch ohne erweiterte Attribute zu betreiben, dann kann die Sicherheitsrichtlinie jedoch nicht angepasst werden
  • SMACK bindet Sicherheitslabel beim Empfang an IP-Pakete
    • Die Sicherheitsrichtlinie kann benutzt werden, um die Kommunikation von Anwendungen auf bestimmte IP-Adressen oder Netzwerke zu beschränken
    • Diese Funktion von SMACK kann zu Performance-Verlusten bei der Netzwerkkommunikation führen, wenn SMACK im Kernel aktiv ist
• SMACK Kernek Dokumentation
• Heise iX: SMACK im Linux Kernel

• AppArmor ist bei Debian 10 installiert und aktiviert
• AppArmor Wiki http://wiki.apparmor.net/index.php/Main_Page
• Im Gegensatz zu SELinux definiert AppArmor die Sicherheits-Richtlinien auf Basis von Dateisystem-Pfaden und nicht auf Dateisystem-Attributen

• 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

• netstat - auf welchen Ports horchen Programme

netstat -tulpen

• netstat - welche Verbindungen sind aktuell offen

netstat -puten

• socket-stat

ss -tu46a

• lsof, alle Verbindungen und offenen Ports anzeigen

lsof -i

• Scan von aussen auf den Server per nmap

yum install nmap
# TCP-Scan mit Betriebssystem-Erkennung
nmap -sT -O 192.168.1.235
# kein DNS, kein Ping, TCP-Connect-Scan, UDP-Connect-Scan, alle Ports
nmap -n -Pn -sT -sU -p-  192.168.1.235

• IPv6 nmap Scan

nmap -6 -sT -O 2001:4dd0:ff00:809d:216:d3ff:feb0:9c3

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

• Folien: http://notes.defaultroutes.de/dnssec-intro.html
• PDF-Druck Version für Chrome: http://notes.defaultroutes.de/dnssec-intro.html?print-pdf

• In den letzten Jahren hat die IETF das DNS-Protokoll um Datenschutzfunktionen erweitert
  • DNS-over-TLS (Transport-Verschlüsselung zwischen DNS-Client und DNS-Resolver)
  • DNS-over-HTTPS (Transport-Verschlüsselung zwischen DNS-Client und DNS-Resolver)
  • QNAME-Minimierung (weniger Metadaten im DNS)
  • EDNS-Padding (Verstecken von DNS-Daten in verschlüsselten Verbindungen)

• Eine auf der IETF 105 im Rahmen des Applied Networking Research (ANR) Workshop im Juli 2019 vorgestellte Studie ergab, dass
  • 8,5 % der Netzwerke (AS) DNS-Anfragen abfangen (27,9 % in China)
  • (heute) die meisten abgefangenen Anfragen (noch) unverändert beantwortet werden
• aber die Situation könnte sich ändern, die Abfangserver könnten DNS-Antworten ändern

• Terminology
  • Do53 = DNS-over-Port53 - klassisches DNS (UDP/TCP Port 53)
  • DoT = DNS-over-TLS - TLS als Transport für DNS
  • DoH = DNS-over-HTTPS - HTTPS als Transport für DNS
  • DoQ = DNS-over-QUIC - QUIC als Transport für DNS
  • DoC = DNS-over-Cloud - DNS Namensauflösung via Cloud-Diensten (Google, Q9, Cloudflare …)

• RFC 7858 "Specification for DNS over Transport Layer Security (TLS)"
• DNS wireformat over TLS over TCP
• Port 853 (TCP)
• Verschlüsselung und Authentisierung (Internet PKI oder via DANE)

• RFC 8484 DNS Queries over HTTPS (DoH) (P. Hoffman, ICANN and P. McManus, Mozilla) https://tools.ietf.org/html/rfc8484
• DNS HTTP-Format over HTTPS over TCP, Port 443 (HTTP/2)
• URL: https://server/dns-query{?dns}
• Verschlüsselung, Autentisierung und Verschleierung

• IETF 100 - November 2017 - DNS over HTTP(S) (DoH) workinggroup started: https://datatracker.ietf.org/wg/doh/about/
• IETF 101 - March 2018 - work on DNS Queries over HTTPS finished, start of working group last call (WGLC) in April 2018
• October 2018 - RFC 8484 published

Zitat aus RFC 8484:

Operational Considerations […] Filtering or inspection systems that rely on unsecured transport of DNS will not function in a DNS over HTTPS environment due to the confidentiality and integrity protection provided by TLS.

• Unterschiede zwischen DoT und DoH
  • DoT kann leicht blockiert werden, da es über einen speziellen Port (853) läuft.
  • DoH sieht wie normaler HTTPS-Verkehr aus, selektives Blockieren von DoH ist schwierig
  • DoH scheint einfacher zu implementieren zu sein, da bereits viele HTTPS Bibliotheksfunktionen in Programmiersprachen existieren
  • DoH ermöglicht es Entwicklern, die DNS-Namensauflösung auf Anwendungsebene durchzuführen (dies kann problematisch sein, das es pro Computer keine einheitliche Namensauflösung mehr gibt)

• Um möglichst viele der Internetnutzer zu erreichen, die einen Schutz der Privatsphäre benötigen, muss DoH standardmäßig aktiviert sein
  • Die (Vor-)Auswahl des DoH-Servers kann ähnlich wie die Auswahl der CA im Browser betrachtet werden
• eine feste Auswahl "pro Region" führt (immer noch) zu einer Zentralisierung aller DNS-Anfragen bei einigen wenigen DNS-Betreibern
  • aber das könnte auch ohne DoH der Fall sein, einige Länder in Asien senden > 90% der DNS-Anfragen an DoC (Google)
• Die IETF arbeitet an neuen Protokollspezifikationen, die es den Kunden ermöglichen, sichere und vertrauenswürdige DNS-Resolver zu finden (ADD "Adaptive DNS Discovery" Working Group https://datatracker.ietf.org/wg/add/about/)

• Mozilla hat eine Prüfung auf eine Canary Domain im Firefox implementiert
• Der Domain-Name der Canary-Domain ist use-application-dns.net.
• Wenn dieser Domain-Name über DNS53 -> unmanaged DNS aufgelöst werden kann, kann DoH auto-aktiviert werden
• wenn der Domain-Name nicht aufgelöst werden kann (= gesperrt ist) -> managed DNS, DoH wird nicht automatisch aktiviert (aber Benutzer können DoH manuell aktivieren)
• IETF diskutiert eine ähnliche Signalisierung: "Signaling resolver's filtering policies" (draft-mglt-add-signaling-filtering-policies)

• Ziele (direkt aus dem Internet-Entwurf übernommen):
  • Keine andere Partei als der Client und der Server kann die vom Client abgefragten Namen oder die vom Server zurückgegebenen Antworten lesen oder kontrollieren
  • Nur ein designierter DNS-Resolver, welcher organisatorisch zu dem Server gehört, welcher auch die Inhalte hostet, ist in der Lage, sowohl die Client IP-Adresse und die abgefragten Namen für datenschutzsensible Verbindungen lesen.
  • Clients sind in der Lage, die von VPNs und lokalen Netzwerken geforderten Richtlinien einzuhalten

• 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