Homelab

Firewall

Die zentrale Rolle als Firewall- und Routing-Plattform des Homelabs spielt OPNsense. Dort sind die verschiedenen Netzsegmente als VLANs definiert, deren Datenverkehr durch entsprechende Firewall-Regeln gesteuert wird. Die Vergabe von IP-Adressen sowie die Zuweisung von Gateway und DNS-Servern für die einzelnen Netze erfolgt zentral über den integrierten DHCP-Server von OPNsense. Bei Bedarf lässt sich der Internetverkehr einzelner VLANs auch über die WireGuard-Schnittstelle von OPNsense routen.

Firewall-Regeln

Die Reihenfolge der Firewall-Regeln ist entscheidend, da OPNsense diese strikt von oben nach unten verarbeitet. Sobald eine Regel greift, also eine Verbindung explizit erlaubt oder blockiert wird, erfolgt keine weitere Prüfung der nachfolgenden Regeln.
Es zählt somit immer die erste zutreffende Regel; alle weiteren Einträge bleiben für diese Verbindung unberücksichtigt.
Ist die erste Regel beispielsweise eine ‘Allow any’-Regel, werden alle Verbindungen bereits dort erlaubt, selbst wenn darunter spezifischere Block-Regeln definiert sind. Deshalb sollten restriktive oder spezifische Regeln grundsätzlich vor allgemeineren Allow-Regeln platziert werden. Das folgende Schema kann dabei hilfreich sein:

Deep-Packet-Inspection

Um zu verhindern, dass der lokale DNS-Server über verschlüsselte Protokolle umgangen wird, müssen DoH (DNS over HTTPS) und DoT (DNS over TLS) blockiert werden. Da sich insbesondere DoH im regulärem HTTPS-Verkehr verbirgt, scheidet klassisches Stateful-Packet-Filtering als Lösungsmöglichkeit aus. Mit der Analyse des Datenverkehrs auf Anwendungsebene & der damit einhergehenden Applikationserkennung durch Deep-Packet-Inspection (DPI), können hingegen auch verschlüsselte Protokolle erkannt & eingeschränkt werden.

OPNsense ist keine vollwertige Next-Generation-Firewall (NGFW) und bietet daher keine umfassenden DPI-Fähigkeiten im Standardumfang. Durch die Integration von Zenarmor lässt sich diese Funktionalität jedoch nachrüsten.

DNS-Server

Grundsätzlich werden alle DNS-Anfragen durch die Firewall blockiert, die nicht explizit an den lokalen DNS-Server gerichtet sind. Dort werden eingehende DNS-Anfragen zunächst durch AdGuard Home auf Werbung, Tracking und Malware überprüft & dann entsprechend blockiert, bzw. an AdGuards Upstream DNS-Server, Unbound weitergeleitet.

AdGuard Home

AdGuard Home ist ein DNS-Server, der als sogenanntes DNS-Sinkhole arbeitet. Er übernimmt die Auflösung von Domainnamen in IP-Adressen, gleicht jedoch gleichzeitig alle DNS-Anfragen von Geräten im lokalen Netzwerk mit hinterlegten Filterlisten ab.

Wird eine angefragte Domain in einer dieser Listen gefunden, liefert AdGuard Home statt der korrekten IP-Adresse bewusst eine ungültige Adresse zurück. Für den Webbrowser wirkt dies so, als existiere die Domain nicht, sodass die Verbindung nicht zustande kommt. Auf diese Weise lassen sich Zugriffe auf Werbe-, Tracking- und potenziell schädliche Domains effektiv unterbinden. Besonders relevant ist dieser Ansatz für IoT-Geräte, die häufig nur unzureichende Sicherheitsmechanismen besitzen und daher von netzwerkseitiger Filterung profitieren.

Unbound

Unbound ist ein rekursiver DNS-Resolver, der die Namensauflösung eigenständig durchführt und dabei nicht auf die DNS-Server von Providern oder Drittanbietern angewiesen ist. Statt Anfragen lediglich weiterzuleiten, löst Unbound Domains schrittweise selbst auf. Dabei kontaktiert Unbound zunächst einen Root-Nameserver, um den zuständigen Server für die jeweilige Top-Level-Domain (TLD) zu ermitteln. Anschließend fragt Unbound den entsprechenden TLD-Nameserver & schließlich den autoritativen Nameserver der Ziel-Domain.

Dieses Vorgehen verbessert die Privatsphäre, da keine einzelne externe Instanz die vollständige DNS-Anfrage einsehen kann. Zudem speichert Unbound erhaltene Antworten im lokalen Cache, wodurch häufig angefragte Domains schneller aufgelöst werden, was sich positiv auf Gesamtperformance auswirkt.

Network-Segmentation

Netzwerksegmentierung ist ein architektonischer Ansatz zur Aufteilung eines Netzwerks in logisch getrennte Segmente, die jeweils als eigenständige Teilnetze fungieren. Netzwerksegmentierung wird dabei häufig durch Virtual-Local-Area-Networks (VLANs) umgesetzt. VLANs ermöglichen die logische Trennung eines physischen Netzwerks, ohne dass separate Verkabelung oder dedizierte Hardware erforderlich sind.

Geräte innerhalb desselben VLANs können direkt miteinander kommunizieren, als befänden sie sich im gleichen physischen Segment. Kommunikation zwischen unterschiedlichen VLANs ist hingegen ausschließlich über die Firewall möglich, wo der Datenverkehr entsprechend gefiltert wird.

Diese Form der Isolation erhöht die Sicherheit erheblich, denn im Falle eines Sicherheitsvorfalls bleibt die Auswirkung in der Regel auf das betroffene Segment beschränkt, wodurch eine seitliche Ausbreitung innerhalb des Netzwerks effektiv verhindert wird.

Layer-3

Jedem Switch-Port ist ein bestimmtes VLAN zugewiesen. Für die Ports [1-8] der beiden Switches die VLANs [21-28], bzw. entsprechend die VLANs [31-38] Die Adressvergabe (IPv4 & IPv6) erfolgt via DHCP auf der OPNsense nach dem Schema:

Layer-2

Port Isolation beschränkt die Kommunikation zwischen bestimmten Ports auf demselben Switch. Wenn Port Isolation aktiviert ist, können Geräte, die an isolierte Ports angeschlossen sind, nicht miteinander kommunizieren. Sämtlicher Layer-2-Traffic zwischen den Switch-Ports [2-8] ist durch Port Isolation blockiert. Kommunikation zwischen Endgeräten an unterschiedlichen Switch-Ports muss damit zwingend über die Firewall erfolgen, die grundsätzlich jede Verbindung blockiert, die nicht explizit durch eine entsprechende Firewall-Regel erlaubt ist.

Endpoint-Security (Server)

Endpoint Security für Server sind Maßnahmen zum Schutz vor Angriffen, die durch die Firewall nicht abgewendet werden konnten. Ziel ist es, die Angriffsfläche der Server zu minimieren und Fehlkonfigurationen zu vermeiden. Zu den grundlegenden Schutzmaßnahmen zählen insbesondere ein konsequentes Update-Management, eine sichere SSH-Konfiguration, der Einsatz einer lokalen Firewall, regelmäßige Backups und Sandboxing zur Isolation potenziell unsicherer Prozesse.

Updates

Sobald eine Sicherheitslücke in einer Software öffentlich wird, beginnt ein Wettlauf zwischen Herstellern und Angreifern. Während die Hersteller versuchen die Sicherheitslücke möglichst schnell zu schließen & entsprechende Patches zur Verfügung zu stellen, suchen die Angreifer nach Möglichkeiten die Schwachstelle auszunutzen. Daher ist es wichtig verfügbare Updates möglichst zeitnah durchzuführen. Unter Linux lassen sich Sicherheitsupdates durch die Installation von unattended-upgrades automatisieren.

Aktivieren.

sudo dpkg-reconfigure unattended-upgrades

Testen.

sudo unattended-upgrade --dry-run -v

SSH-Login

Eine wirkungsvolle Maßnahme zur Reduktion der Angriffsfläche eines Server-Systems ist das Deaktivieren des Passwort-Login. Stattdessen sollte der SSH-Login ausschließlich via Public-Key-Authentifizierung möglich sein. Selbst wenn starke Passwörter verwendet werden, bleibt das System grundsätzlich anfällig für Brute-Force-und Dictionary-Angriffe, wobei Angreifer systematisch Benutzername/Passwort-Kombinationen ausprobieren. Tools wie fail2ban können das Risiko zwar reduzieren, aber nicht vollständig eliminieren.

Public-Key ~/.ssh/srv_root_nextcloud.pub & Private-Key ~/.ssh/srv_root_nextcloud erstellen.

ssh-keygen -t ed25519 -f ~/.ssh/srv_root_nextcloud -C "root@nextcloud.home.arpa"

Alias für SSH-Login anlegen.

echo "# ssh-login nextcloud.home.arpa" >> ~/.bashrc && \
echo "alias ssh_nextcloud='ssh -i ~/.ssh/srv_root_nextcloud root@192.168.37.11'" >> ~/.bashrc && \
unalias -a && source ~/.bashrc

Um Probleme mit SSH-Agent bei mehreren hinterlegten Schlüsseln zu vermeiden, empfiehlt es sich, entsprechende Aliase anzulegen, wo der jeweils zu verwendende Schlüssel explizit definiert ist.

Konfiguration in /etc/ssh/sshd_config für Pubkey-Login-Setup anpassen.

sudo sed -i 's/#Port 22/Port 22/' /etc/ssh/sshd_config && \
sudo sed -i 's/#AddressFamily any/AddressFamily inet/' /etc/ssh/sshd_config && \
sudo sed -i 's/#ListenAddress 0.0.0.0/ListenAddress 0.0.0.0/' /etc/ssh/sshd_config && \
sudo sed -i 's/#PermitRootLogin prohibit-password yes/PermitRootLogin yes/' /etc/ssh/sshd_config && \
sudo systemctl restart sshd

Auf Ubuntu-Servern muss evtl. noch der user [root] aktiviert & ein Passwort gesetzt werden.

sudo passwd root && passwd -u root 

Public-Key ~/.ssh/srv_root_nextcloud.pub nach nextcloud.home.arpa, bzw. 192.168.37.11 kopieren.

ssh-copy-id -i ~/.ssh/srv_root_nextcloud.pub root@192.168.37.11

Konfiguration in /etc/ssh/sshd_config absichern.

sudo sed -i 's/PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config && \
sudo sed -i 's/UsePAM yes yes/UsePAM no/' /etc/ssh/sshd_config && \
sudo sed -i 's/X11Forwarding yes/X11Forwarding no/' /etc/ssh/sshd_config && \
sudo sed -i 's/#AllowTcpForwarding no/AllowTcpForwarding no/' /etc/ssh/sshd_config && \
sudo sed -i 's/#AllowAgentForwarding no/AllowAgentForwarding no/' /etc/ssh/sshd_config && \
sudo systemctl restart sshd

Konfiguration, überprüfen.

/usr/bin/clear && \
sudo sshd -T | grep -E "(addressfamily|listenaddress|maxauthtries)" && \
sudo sshd -T | grep -E "(passwordauthentication|pubkeyauthentication|usepam|kbdinteractiveauthentication)" && \
sudo sshd -T | grep -E "(x11forwarding|allowtcpforwarding|allowagentforwarding)"

Iptables

Als hostbasierter Paketfilter spielt Iptables eine zentrale Rolle in der Absicherung von Linux Endpoints, wie Server & Workstations. Ein- und Ausgehender Netzwerkverkehr wird nalysiert & entsprechend vordefinierten Regeln zugelassen, geblockt oder verworfen.

Installation.

sudo apt update && \
sudo apt upgrade -y && \
sudo apt install -y --no-install-suggests iptables-persistent

Systemd-Service aktivieren & starten.

sudo systemctl enable iptables && \
sudo systemctl start iptables

Neue Datei erstellen, im Editor öffnen, Iptables-Script einfügen & Editor schließen.

sudo mkdir /opt/iptables && \
sudo touch /opt/iptables/fwv4-start.sh && \
sudo nano /opt/iptables/fwv4-start.sh

Das Iptables-Script für die IPv6-Konfiguration gibt es hier.

Iptables-Script starten.

sudo bash /opt/iptables/fwv4-start.sh

Aktive Iptables-Regeln anzeigen.

sudo iptables -v -L -n --line-numbers

Blockierte Verbindungen in /var/log/syslog anzeigen.

sudo tail -f /var/log/syslog | grep 'iptables_'

Iptables beenden.

sudo systemctl stop iptables

Systemzeit

Eine genaue und aktuelle Systemuhrzeit ist auf Linux-Systemen absolut entscheidend, vor allem aus Sicherheitsgründen. Beispielsweise haben TLS/SSL-Zertifikate ein Gültigkeitsfenster und eine falsche Uhrzeit kann dazu führen, dass Zertifikate abgelehnt werden, was sich dann im Browser oder in Apps als nicht funktionierende HTTPS-Verbindungen äußert. Gerade im Server-Bereich kann eine falsche Systemzeit die Aussagekraft von Log-Dateien erheblich einschränken.

Chrony

Chrony ist ein Dienst zur Zeitsynchronisation unter Linux und gleicht die Systemzeit kontinuierlich mit einem Zeitserver ab. Chrony besteht typischerweise aus dem Hintergrunddienst chronyd, der die Synchronisation übernimmt, sowie dem Kommandozeilenwerkzeug chronyc, mit dem sich die Zeitsynchronisation überprüfen lässt.

Installation.

sudo apt update && \
sudo apt upgrade -y && \
sudo apt install -y --no-install-suggests tzdata chrony

Systemd-Service aktivieren & starten.

sudo systemctl enable chrony && \
sudo systemctl start chrony

Fritzbox als Zeitserver konfigurieren.

sudo sed -i '5i server 192.168.0.1 iburst' /etc/chrony/chrony.conf && \
sudo sed -i 6d /etc/chrony/chrony.conf && \
sudo sed -n 5p /etc/chrony/chrony.conf && \
sudo systemctl restart chrony

Zeitsynchronisation überprüfen.

sudo chronyc tracking

Backup

Regelmäßige Backups sind nicht nur ein Mittel zur Datenrettung, bei Hardwaredefekten, Fehlkonfiguration oder versehentlichem Löschen, sondern auch essenzieller Teil der IT-Sicherheit. Besonders deutlich wird das am Beispiel von Ransomware, wo Daten auf kompromittierten Systemen verschlüsselt werden. Ein aktuelles Backup ermöglicht die Wiederherstellung des betroffenen Systems, ohne den Lösegeldforderungen nachzukommen. aus einem aktuellen Backup und Lösegeldforderungen gestellt werden. gefordert wird. Als letzte Verteidigungslinie stellen regelmäßige Backups damit sicher, dass auch nach einem erfolgreichen Angriff keine irreversiblen Schäden zurückbleiben.

Restic

Restic ist ein plattformübergreifendes Open-Source-Tool mit dem sich inkrementelle & deduplizierte Backups erstellen lassen. Dabei richtet sich Restic vor allem an fortgeschrittene Benutzer, die sich an der Kommandozeile wohlfühlen, denn eine graphische Oberfläche gibt es nicht. Restic benötigt keinen dedizierten Server & unterstützt neben lokalem Speicher eine Reihe weiterer Backup-Ziele, wie SSH & Cloud-Storage.

Installation.

sudo apt update && \
sudo apt upgrade -y && \
sudo apt install --no-install-suggests restic

Backup-Repository inititalisieren.

export RESTIC_PASSWORD='password' && \
export RESTIC_REPOSITORY='sftp:skylake@192.168.37.13:/home/skylake/restic' && \
restic -r $RESTIC_REPOSITORY init

Neue Datei erstellen, im Editor öffnen, Restic-Includes-Datei einfügen, Datei anpassen, Editor schließen.

mkdir ~/restic && \
touch ~/restic/my_backup.txt && \
nano ~/restic/my_backup.txt

Backup starten.

restic backup --files-from ~/restic/my_backup.txt

Backups anzeigen.

restic snapshots

Das Beispielskript kann beispielsweise zur Automatisierung über einen Cronjob gesteuert werden.

crontab -e

Folgende Zeile anfügen, speichern & beenden.

20 4 * * * /usr/bin/bash /home/sudoscience/restic/restic_backup.sh backup >/dev/null 2>&1

Cronjob für automatisiertes, tägliches Backup um 4:20 Uhr.

Sandboxing

Sandboxing ist eine Technik, bei der Programme in einer abgeschotteten Umgebung ausgeführt werden, sodass sie keinen direkten Zugriff auf das restliche System haben. Der Zugriff auf Dateien, Netzwerk oder Hardware des Host-Systems wird eingeschränkt oder blockiert. Damit bleiben Schäden auf die Sandbox begrenzt.

AppArmor

AppArmor ist ein Open-Source-Sandbox-Tool für Linux, was sich gut zur Absicherung von Servern eignet. Server sind in der Regel dauerhaft exponiert und müssen gezielt gegen externe Angriffe abgesichert werden. Hier ist es entscheidend, dass Prozesse dauerhaft, strikt isoliert sind, unabhängig davon, ob ein Server-Dienst läuft, oder nicht & der Zugriff auf die Ressourcen des Host-Systems ausschließlich entsprechend der in AppArmor definierten Regeln erfolgt.

Installation.

sudo apt update && \
sudo apt upgrade -y && \
sudo apt install -y --no-install-suggests apparmor apparmor-utils apparmor-profiles apparmor-profiles-extra

AppArmor aktivieren & starten.

sudo systemctl enable apparmor.service && \
sudo systemctl restart apparmor.service

Aktive AppArmor-Profile anzeigen.

sudo aa-status

Endpoint-Security (Desktop)

Die unter Endpoint-Security (Server) genannten Maßnahmen sollten grundsätzlich auch auf Desktop-Systeme übertragen werden. Ergänzend empfiehlt sich der Einsatz eines Passwortmanagers, eine Härtung der Firefox-Konfiguration sowie die Ausführung von Desktop-Anwendungen innerhalb einer isolierten Firejail-Sandbox.

Backup

Vorta erweitert das mächtige Backup-Tool BorgBackup um eine graphische Benutzeroberfläche & ermöglicht damit einen komfortablen Zugriff auf die wichtigsten Funktionen, ohne dass sich die Benutzer mit den komplexen Kommandozeilenbefehlen auseinandersetzen müssen. Über die benutzerfreundliche Oberfläche lassen sich die zu Sichernden Daten auswählen, automatisierte Backups einrichten & verwalten. Indem es die Vorteile des leistungsstarken BorgBackup mit einer übersichtlichen Benutzeroberfläche kombiniert, eignet sich Vorta hervorragend für die Verwendung auf Linux-Desktops.

Passwort-Manager

Ohne Hilfsmittel verwenden viele Nutzer identische und schwache Passwörter für mehrere Accounts. Wird der entsprechende Dienst eines Accounts, beispielsweise eines Online-Shops kompromittiert, etwa durch ein Datenleck, besteht das Risiko, dass Angreifer versuchen sich mit den geleakten Zugangsdaten bei anderen Diensten einzuloggen. Ein Passwort-Manager dagegen generiert für jeden Dienst starke, zufällige & einzigartige Passwörter. Damit kann das Risiko durch Brute-Force-Attacken, Dictionary-Angriffe und Passwort-Leaks minimiert werden.

Enpass

Enpass ist ein kommerzieller Passwort-Manager und keine Open-Source-Software. Damit ist Enpass als proprietäre Sofware zwar weniger transparent, als entsprechende Open-Source-Alternativen, bietet dafür aber deutlich mehr Benutzerfreundlichkeit.

KeePassXC

KeePassXC ist ein kostenlos verfügbarer Open-Source-Password-Manager, der sowohl für Linux, als auch für MacOS & Windows verfügbar ist. Im Gegensatz zu proprietären Lösungen ist es nicht notwendig einem einzigen Hersteller zu vertrauen, da der Quellcode öffentlich einsehbar ist. Für technikaffine Nutzer ist KeePassXC eine flexible & robuste Lösung, die jedoch mehr auf Funktionalität als auf Komfort ausgelegt ist.

Firefox

Umfangreiche Telemetrie und Tracking Funktionen sind heutzutage leider fester Bestandteil gängiger Browser, wie Chrome, Safari, Edge und Firefox. Der quelloffene und kostenlos verfügbare Firefox kann jedoch durch gezielte Anpassungen und Addons zu einem datenschutzfreundlichen Browser aufgewertet werden.

Profile

Für eine saubere Trennung von Nutzungskontexten (z. B. Arbeit, Privat, Testing) unterstützt Firefox mehrere Profile. Jedes Profil hat eine eigene Konfiguration, Add-ons und isolierte Datenbasis – ein wichtiger Baustein zur Minimierung der Angriffsfläche.

Profilmanager starten.

firefox –no-remote -P

Der Parameter ‘-no-remote’ bewirkt, dass mehrere Firefox-Profile parallel ausgeführt werden können.

Arkenfox

Für ein gehärtetes Setup empfiehlt sich der Einsatz von Arkenfox. Dabei handelt es sich um eine Sammlung sicherheits- und datenschutzrelevanter Einstellungen, die systematisch Tracking, Fingerprinting und unnötige Hintergrundkommunikation reduzieren. Anpassungen können granular über Overrides vorgenommen werden, sodass ein guter Kompromiss zwischen Sicherheit und Usability möglich bleibt.

Wechsel in Profilverzeichnis & Download der Arkenfox-Dateien.

cd ~/.config/mozilla/firefox/geb2qc3m.Arbeit && \
wget -c https://raw.githubusercontent.com/arkenfox/user.js/refs/heads/master/user.js && \
wget -c https://raw.githubusercontent.com/arkenfox/user.js/refs/heads/master/updater.sh && \
wget -c https://raw.githubusercontent.com/arkenfox/user.js/refs/heads/master/prefsCleaner.sh && \
touch user-overrides.js && \
cd ~

Wechsel in Profilverzeichnis & Aktivieren der Arkenfox-Konfiguration.

cd ~/.config/mozilla/firefox/geb2qc3m.Arbeit && \
bash updater.sh && \
bash prefsCleaner.sh && \
cd ~

Profilemaker

Unterstützung beim Erstellen einer individuellen Konfigurationsdatei bietet das Tool Profilemaker. Nachdem die gewünschten Einstellung im Wizard des Profilemakers gesetzt sind, kann die fertige Konfigurationsdatei heruntergeladen werden. Eine weitere Möglichkeit ist die Kombination mit Arkenfox, indem der Inhalt der Konfigurationsdatei aus dem Profilemaker in die Datei user-overides.js aus dem Arkenfox-Setup kopiert wird.

Wechsel in Downloadverzeichnis & Inhalt der Konfigurationsdatei kopieren.

cd ~/.config/mozilla/firefox/geb2qc3m.Arbeit && \
cat ~/Downloads/prefs.js > user-overrides.js && \
bash updater.sh && \
bash prefsCleaner.sh && \
cd ~

Sandboxing

Wie AppArmor handelt es sich auch bei Firejail um ein Open-Source-Sandbox-Tool für Linux. Die Isolation von Anwendungen durch Firejail ist nicht dauerhaft, da die Sandbox erst mit dem Start einer Anwendung initialisiert wird. Dadurch eignet sich Firejail besonders für den Einsatz auf Desktop-Systemen. Auf Desktops entstehen Risiken häufig durch das Ausführen potenziell unsicherer Inhalte wie Downloads oder Webseiten. Hier geht es weniger um eine dauerhafte & komplexe Zugriffskontrolle, als um die Begrenzung des Schadens bei der Ausführung unsicherer Anwendungen & Inhalten.

Installation.

sudo apt update && \
sudo apt upgrade -y && \
sudo apt install -y --no-install-suggests firejail firejail-profiles

Firejails AppArmor-Profil laden.

sudo aa-enforce firejail-default

Firejail starten.

sudo firecfg

Firejail beenden.

sudo firecfg --clean

#!/usr/bin/env bash

# 1. Clear current configuration
iptables -F
iptables -X
iptables -Z
iptables -Z -t nat
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
iptables -t raw -F
iptables -t raw -X

# 2. Create chains.
iptables -N TCP
iptables -N UDP

# 3. Set default policy.
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT

# 4. Standard rules.
iptables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m conntrack --ctstate INVALID -j DROP
iptables -A INPUT -p icmp -m icmp --icmp-type 8 -m conntrack --ctstate NEW -j ACCEPT

# 5. Dispatch new connections chains.
iptables -A INPUT -p udp -m conntrack --ctstate NEW -j UDP
iptables -A INPUT -p tcp --tcp-flags FIN,SYN,RST,ACK SYN -m conntrack --ctstate NEW -j TCP

# 6. Allow inbound TCP traffic.
# iptables -A TCP -p tcp --dport 22 -j ACCEPT
# iptables -A TCP -p tcp --dport 53 -j ACCEPT
# iptables -A TCP -p tcp --dport 80 -j ACCEPT
# iptables -A TCP -p tcp --dport 139 -j ACCEPT
# iptables -A TCP -p tcp --dport 443 -j ACCEPT
# iptables -A TCP -p tcp --dport 445 -j ACCEPT
# iptables -A TCP -p tcp --dport 1081 -j ACCEPT
# iptables -A TCP -p tcp --dport 3128 -j ACCEPT
# iptables -A TCP -p tcp --dport 8118 -j ACCEPT

# 7. Allow inbound UDP traffic.
# iptables -A UDP_$IF1 -p udp --dport 53 -j ACCEPT
# iptables -A UDP_$IF1 -p udp --dport 137 -j ACCEPT
# iptables -A UDP_$IF1 -p udp --dport 138 -j ACCEPT
# iptables -A UDP_$IF1 -p udp --dport 139 -j ACCEPT

# 10. Reject/Log everything else.
iptables -A INPUT -p udp -j LOG --log-prefix "[iptables_ipv4_udp]: " --log-level 7 --log-uid
iptables -A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable
iptables -A INPUT -p tcp -j LOG --log-prefix "[iptables_ipv4_tcp]: " --log-level 7 --log-uid
iptables -A INPUT -p tcp -j REJECT --reject-with tcp-reset
iptables -A INPUT -j LOG --log-prefix "[iptables_ipv4]: " --log-level 7 --log-uid
iptables -A INPUT -j REJECT --reject-with icmp-proto-unreachable

# 11. Persist rules.
mkdir -p /etc/iptables
iptables-save > /etc/iptables/rules.v4

# 12. Display info in terminal.
echo ""
echo "[IPv4] packets will be FILTERED."
echo ""

#!/usr/bin/env bash

# 1. Clear current configuration.
ip6tables -F
ip6tables -F -t nat
ip6tables -X
ip6tables -Z
ip6tables -Z -t nat
ip6tables -t nat -F
ip6tables -t nat -X
ip6tables -t mangle -F
ip6tables -t mangle -X
ip6tables -t raw -F
ip6tables -t raw -X

# 2. Create chains.
ip6tables -N TCP
ip6tables -N UDP

# 3. Set default policy.
ip6tables -P INPUT DROP
ip6tables -P FORWARD DROP
ip6tables -P OUTPUT ACCEPT

# 4. Standard rules.
ip6tables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
ip6tables -A INPUT -i lo -j ACCEPT
ip6tables -A INPUT -m conntrack --ctstate INVALID -j DROP

# Rules for ICMPv6 und DHCPv6.
ip6tables -A INPUT -s fe80::/10 -p ipv6-icmp -j ACCEPT
ip6tables -A INPUT -p udp --sport 547 --dport 546 -j ACCEPT
ip6tables -A INPUT -p ipv6-icmp -m icmp6 --icmpv6-type 128 -m conntrack --ctstate NEW -j ACCEPT

# 5. Dispatch new connections to chains.
ip6tables -A INPUT -p tcp --tcp-flags FIN,SYN,RST,ACK SYN -m conntrack --ctstate NEW -j TCP
ip6tables -A INPUT -p udp -m conntrack --ctstate NEW -j UDP

# 6. Allow inbound TCP traffic.
# ip6tables -A TCP -p tcp --dport 22 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 80 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 139 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 443 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 445 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 1081 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 3128 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 8118 -j ACCEPT

# 8. Allow inbound UDP traffic.
# ip6tables -A UDP -p udp --dport 53 -j ACCEPT
# ip6tables -A UDP -p udp --dport 138 -j ACCEPT
# ip6tables -A UDP -p udp --dport 138 -j ACCEPT
# ip6tables -A UDP -p udp --dport 139 -j ACCEPT

# 8. Reject/Log everything else.
ip6tables -A INPUT -p udp -j LOG --log-prefix "[iptables_ipv6_udp]: " --log-level 7 --log-uid
ip6tables -A INPUT -p udp -j REJECT --reject-with icmp6-adm-prohibited
ip6tables -A INPUT -p tcp -j LOG --log-prefix "[iptables_ipv6_tcp]: " --log-level 7 --log-uid
ip6tables -A INPUT -p tcp -j REJECT --reject-with tcp-reset
ip6tables -A INPUT -j LOG --log-prefix "[iptables_ipv6]: " --log-level 7 --log-uid
ip6tables -A INPUT -j REJECT --reject-with icmp6-adm-prohibited

# 9. Persist rules.
mkdir -p /etc/iptables
ip6tables-save > /etc/iptables/rules.v6

# 10. Display info in terminal.
echo ""
echo "[IPv6] packets will be FILTERED."
echo ""

# /home/sudoscience/restic/my_backup.txt
/home/sudoscience/.config
/home/sudoscience/.local/share
/home/sudoscience/.mozilla
/home/sudoscience/.thunderbird
/home/sudoscience/configs
/home/sudoscience/Desktop
/home/sudoscience/Documents
/home/sudoscience/Music
/home/sudoscience/myvault
/home/sudoscience/pdfs
/home/sudoscience/PhpstormProjects
/home/sudoscience/Pictures
/home/sudoscience/PycharmProjects
/home/sudoscience/scripts
/home/sudoscience/Videos

#!/usr/bin/env bash

## [RESTIC] BACKUP ##
skylake() {
	export RESTIC_PASSWORD='password'
	export RESTIC_REPOSITORY='sftp:skylake@192.168.37.13:/home/restic'
	INCEXC='/home/sudoscience/restic/'
  if [ "$1" = "backup" ]; then
    /usr/bin/restic backup --files-from $INCEXC/my_backup.txt
  elif [ "$1" = "snapshots" ]; then
  	/usr/bin/restic snapshots
  elif [ "$1" = "stats" ]; then
    /usr/bin/restic stats --mode raw-data
  elif [ "$1" = "init" ]; then
  	/usr/bin/restic -r $RESTIC_REPOSITORY init
  else
    echo "[ERROR] Please specify task [init, stats, backup, snapshots]."
  fi
}
skylake "$1"