Linux Server Härtung: SSH mit FIDO2/YubiKey & CrowdSec

┌─────────────────────────────────────────────────────────────┐
│                  FIDO2 Challenge-Response                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌──────────────┐       ┌──────────┐      ┌──────────────┐ │
│   │  SSH-Client  │       │  YubiKey │      │  SSH-Server  │ │
│   └──────┬───────┘       └────┬─────┘      └──────┬───────┘ │
│          │                    │                   │         │
│          │ Challenge (random) │                   │         │
│          │ ──────────────────>│                   │         │
│          │                    │  PIN / Touch      │         │
│          │                    │ ────────── (User) │         │
│          │                    │                   │         │
│          │ Signature(Chall.)  │                   │         │
│          │ <───────────────── │                   │         │
│          │                    │                   │         │
│          │ Challenge + Signat.│                   │         │
│          │ ──────────────────────────────────────>│         │
│          │                    │                   │         │
│          │                    │ Verify(PubKey,Sig)│         │
│          │                    │ ───────────────── │         │
│          │                    │                   │         │
│          │ Access Granted     │                   │         │
│          │ <──────────────────────────────────────│         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# YubiKey Manager installieren (Debian/Ubuntu)
sudo apt install yubikey-manager -y

# FIDO2-PIN setzen (Standard-PIN ist leer)
ykman fido access change-pin

# Prüfe ob der YubiKey erkannt wird
ykman fido info

Applications: FIDO2
    slots: 2
     pin: true
     pin retries: 3

# FIDO2-SSH-Schlüssel erzeugen
ssh-keygen -t ed25519-sk -C "admin@server"

# Ohne Touch (nur PIN)
ssh-keygen -t ed25519-sk -O no-touch-required

# Mit benutzerdefiniertem Dateinamen
ssh-keygen -t ed25519-sk -f ~/.ssh/id_yubikey -C "admin@server"

# Öffentlichen Schlüssel auf den Server übertragen
ssh-copy-id -i ~/.ssh/id_ed25519-sk.pub user@server

# Manuelle Installation
cat ~/.ssh/id_ed25519-sk.pub | ssh user@server "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

# Prüfe den installierten Schlüssel
cat ~/.ssh/authorized_keys | grep "sk@"

sudo nano /etc/ssh/sshd_config

# FIDO2-Schlüssel erlauben (Standard: yes)
PubkeyAuthentication yes

# Nur SSH-Keys erlauben (Passwörter deaktivieren)
PasswordAuthentication no

# Root-Login verbieten
PermitRootLogin no

# Maximal 3 Authentifizierungsversuche
MaxAuthTries 3

# Grace Time auf 30 Sekunden begrenzen
LoginGraceTime 30

# Information Disclosure minimieren
DebianBanner no
Banner none

# Keepalive für Long-Running Sessions
ClientAliveInterval 300
ClientAliveCountMax 2

# Nur verifizierte FIDO2-Keys akzeptieren
PubkeyAuthOptions verify-required

sudo systemctl restart sshd

# Login mit FIDO2-Key
ssh -i ~/.ssh/id_ed25519-sk user@server

# Prüfe, welche Methode verwendet wurde
ssh -v user@server 2>&1 | grep "Offering"

# CA-Schlüsselpaar erzeugen
sudo mkdir -p /etc/ssh/ca
sudo ssh-keygen -t ed25519 -f /etc/ssh/ca/server-ca -C "SSH CA"

# Auf jedem Server: CA Public Key als TrustedKey eintragen
echo "cert-authority $(cat /etc/ssh/ca/server-ca.pub)" >> /etc/ssh/authorized_keys.d/trusted-ca

# FIDO2-Key signieren (erzeugt ein Zertifikat)
sudo ssh-keygen -s /etc/ssh/ca/server-ca \
    -I "admin-fido2" \
    -n admin \
    -V +52w \
    ~/.ssh/id_ed25519-sk.pub

# Server-Definition mit FIDO2-Key
Host server
    HostName 192.168.1.100
    User admin
    IdentityFile ~/.ssh/id_ed25519-sk
    IdentitiesOnly yes

# Jump-Host für interne Server
Host internal-server
    HostName 10.0.0.50
    User admin
    ProxyJump server
    IdentityFile ~/.ssh/id_ed25519-sk
    IdentitiesOnly yes

# ssh-agent starten (optional für FIDO2)
eval $(ssh-agent -s)

# Key hinzufügen (Touch wird bei jedem Login angefordert)
ssh-add ~/.ssh/id_ed25519-sk

# Prüfe ob FIDO2 im SSH-Server unterstützt wird
ssh -V  # OpenSSH_8.9 oder höher

# Prüfe die Server-Konfiguration
sudo sshd -T | grep pubkeyauth

# ssh-agent läuft und versucht den Key zu signieren
# Lösung: Key explizit angeben oder Agent deaktivieren
ssh -i ~/.ssh/id_ed25519-sk user@server

# Prüfe ob der YubiKey erkannt wird
lsusb | grep Yubico

# Prüfe ob das FIDO2-Modul geladen ist
ls /dev/hidraw*

# FIDO2-PIN manuell setzen oder zurücksetzen
ykman fido access change-pin

# Logs prüfen
journalctl -u sshd -f

# Erfolgreiche FIDO2-Logins erkennen
journalctl -u sshd | grep "Accepted publickey"

# Repository hinzufügen (Debian/Ubuntu)
curl -s https://packagecloud.io/install/repositories/crowdsec/crowdsec/script.deb.sh | sudo bash

# CrowdSec installieren
sudo apt install crowdsec -y

# Bouncer für nftables/iptables
sudo apt install crowdsec-firewall-bouncer-nftables -y

sudo systemctl status crowdsec
sudo systemctl status crowdsec-firewall-bouncer

● crowdsec.service - CrowdSec SIEM
     Loaded: loaded (/lib/systemd/system/crowdsec.service; enabled)
     Active: active (running) since Mon 2026-08-26 12:00:00 UTC

sudo cscli decisions list

sudo cscli scenarios list

sudo nano /etc/crowdsec/scenarios/custom-ssh-aggressive.yaml

type: leak
name: ssh-aggressive-scan
description: "Aggressive SSH-Scans mit vielen fehlgeschlagenen Logins"
labels:
  service: ssh
  remediation: true
filter:
  LABELS.service == "ssh" && MSG.ContainerName == "sshd"
groupby: LABELS.source_ip
capacity: 5
leakspeed: 1m
blackhole: 1m
certainty: 75
for: 10m

# Scenarios neu laden
sudo cscli scenarios list | grep custom

# Testszenario simulieren
sudo cscli scenarios install --local /etc/crowdsec/scenarios/custom-ssh-aggressive.yaml

# Prüfe ob der Bouncer aktiv ist
sudo cscli bouncers list

Name       │ IP Address │ Valid Until │ Type
───────────┼────────────┼─────────────┼──────
firewall   │ 127.0.0.1  │ 2027-01-01  │ nftables

# CrowdSec-Chain in nftables prüfen
sudo nft list chain inet crowdsec-crowdsec-block

table inet crowdsec-crowdsec {
    chain crowdsec-block {
        type filter hook input priority filter; policy accept;
        ip saddr @crowdsec-blacklist-jump drop
        ip6 saddr @crowdsec-blacklist6-jump drop
    }
}

sudo nano /etc/crowdsec/parsers/s02-enrich/whitelist.yaml

filter: "Meta.IP != ''"
whitelist:
  reason: "Lokale Adresse"
  expression: "Ip('127.0.0.1') || Ip('::1')"
  expression: "Ip('192.168.0.0/16')"
  expression: "Ip('10.0.0.0/8')"

# Einzelne IP whitelishten
sudo cscli decisions add --ip 192.168.1.100 --duration 0 --type whitelist --reason "Monitoring"

# IP-Range whitelishten
sudo cscli decisions add --range 192.168.1.0/24 --duration 0 --type whitelist --reason "Lokales Netz"

# Dashboard-Zugangsdaten anzeigen
sudo cscli console status

# Metriken-Endpunkt prüfen
curl -s http://localhost:6060/metrics | head -20

# Wichtige Metriken
crowdsec_decisions_total{source_ip="...",scenario="..."}
crowdsec_alerts_total{scenario="..."}
crowdsec_bouncers_total{type="..."}

sudo nano /etc/crowdsec/notifications/email.yaml

type: email
name: email_default
log_level: info
 # Email-Konfiguration
smtp_host: "smtp.example.com"
smtp_port: 587
smtp_username: "alert@example.com"
smtp_password: "DEIN_PASSWORT"
smtp_from: "crowdsec@example.com"
smtp_to:
  - "admin@example.com"
smtp_subject: "CrowdSec Alert: {scenario}"
format: |
  CrowdSec hat einen Angriff erkannt.
  Scenario: {scenario}
  Source IP: {source_ip}
  Entscheidung: {decision}
  Zeit: {created_at}

# Notifications prüfen
sudo cscli notifications list

# Test-Benachrichtigung senden
sudo cscli alert inspect --id 1

┌─────────────────────────────────────────────────────────────┐
│              CrowdSec Multi-Server Architektur              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────┐        ┌─────────┐        ┌─────────┐         │
│   │ Server1 │        │ Server2 │        │ Server3 │         │
│   │ Agent   │        │ Agent   │        │ Agent   │         │
│   └────┬────┘        └────┬────┘        └────┬────┘         │
│        │                  │                  │              │
│        ▼                  ▼                  ▼              │
│   ┌─────────────────────────────────────────────────────┐   │
│   │                Lokale API (zentral)                 │   │
│   │                http://central:8080                  │   │
│   └──────────────────────────┬──────────────────────────┘   │
│                              │                              │
│                              ▼                              │
│   ┌─────────────────────────────────────────────────────┐   │
│   │                 Community Database                  │   │
│   │                 (geteilte Decisions)                │   │
│   └─────────────────────────────────────────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

sudo nano /etc/crowdsec/config.yaml

api:
  client:
    insecure_skip_verify: false
  server:
    listen_uri: http://127.0.0.1:8080

# Logs prüfen
sudo journalctl -u crowdsec -f

# Häufige Ursache: Port 8080 belegt
sudo ss -tulnp | grep 8080

# Bouncer-API-Token prüfen
sudo cscli bouncers list

# Token neu generieren
sudo cscli bouncers add my-bouncer --auto

# Whitelist prüfen
sudo cscli decisions list --type whitelist

# Lokale IP zur Whitelist hinzufügen
sudo cscli decisions add --ip 192.168.1.100 --duration 0 --type whitelist --reason "Eigener Server"

# Aktive Decisions prüfen
sudo cscli decisions list

# Logs des Agenten prüfen
sudo journalctl -u crowdsec | grep "decision"

sudo nano /etc/sysctl.d/99-hardening.conf

# IP-Spoofing verhindern
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# ICMP-Redirects deaktivieren
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv6.conf.all.accept_redirects = 0
net.ipv6.conf.default.accept_redirects = 0

# Source-Routing deaktivieren
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

# SYN-Flood-Schutz aktivieren
net.ipv4.tcp_syncookies = 1

# Log Martian-Pakete
net.ipv4.conf.all.log_martians = 1
net.ipv4.conf.default.log_martians = 1

# Address Space Layout Randomization
kernel.randomize_va_space = 2

# Dmesg einschränken (nur für Root)
kernel.dmesg_restrict = 1

# Kernel-Pointer verbergen
kernel.kptr_restrict = 2

# BPF einschränken
kernel.unprivileged_bpf_disabled = 1

# User namespaces einschränken (für Container)
kernel.unprivileged_userns_clone = 0

# Module nicht mehr laden können (nach Boot)
kernel.modules_disabled = 1

sudo sysctl -p /etc/sysctl.d/99-hardening.conf

# Prüfe ob Parameter gesetzt sind
sysctl net.ipv4.conf.all.rp_filter
sysctl kernel.randomize_va_space

net.ipv4.conf.all.rp_filter = 1
kernel.randomize_va_space = 2

# /tmp ist oft bereits ein tmpfs, prüfe mit:
mount | grep tmp

# In /etc/fstab eintragen (bei separater /tmp-Partition)
# UUID=... /tmp ext4 defaults,noexec,nosuid,nodev 0 2

# Kritische Verzeichnisse absichern
sudo chmod 700 /root
sudo chmod 600 /etc/shadow
sudo chmod 600 /etc/gshadow
sudo chmod 644 /etc/passwd
sudo chmod 644 /etc/group

# SSH-Verzeichnis
sudo chmod 700 /root/.ssh
sudo chmod 600 /root/.ssh/authorized_keys

# SUID-Bits auf Standard-Tools prüfen
find / -perm -4000 -type f 2>/dev/null

# Nur wenn die Programme nicht als SUID benötigt werden
sudo chmod u-s /usr/bin/newgrp
sudo chmod u-s /usr/bin/chsh
sudo chmod u-s /usr/bin/chfn

# Alle laufenden Services anzeigen
systemctl list-units --type=service --state=running

# Häufig unnötige Services auf einem Server
systemctl list-units --type=service --state=running | grep -E "cups|bluetooth|avahi|modem"

# Drucker-Service (auf einem Server nicht benötigt)
sudo systemctl stop cups
sudo systemctl disable cups
sudo systemctl mask cups

# Bluetooth (auf einem Server nicht benötigt)
sudo systemctl stop bluetooth
sudo systemctl disable bluetooth
sudo systemctl mask bluetooth

# mDNS/Avahi (Service Discovery – auf einem Server unnötig)
sudo systemctl stop avahi-daemon
sudo systemctl disable avahi-daemon
sudo systemctl mask avahi-daemon

# Security Score für einen Service anzeigen
systemd-analyze security sshd.service

→ Overall exposure level for sshd.service: 9.6 OK

sudo apt install auditd -y
sudo systemctl enable auditd

# SSH-Konfiguration überwachen
sudo auditctl -w /etc/ssh/sshd_config -p wa -k sshd_config

# Authorized-Keys überwachen
sudo auditctl -w /root/.ssh/authorized_keys -p wa -k ssh_keys

# sudo-Konfiguration überwachen
sudo auditctl -w /etc/sudoers -p wa -k sudoers
sudo auditctl -w /etc/sudoers.d/ -p wa -k sudoers

# Crontab überwachen
sudo auditctl -w /etc/crontab -p wa -k cron
sudo auditctl -w /var/spool/cron/ -p wa -k cron

sudo nano /etc/audit/rules.d/hardening.rules

# SSH
-w /etc/ssh/sshd_config -p wa -k sshd_config
-w /root/.ssh/authorized_keys -p wa -k ssh_keys

# Sudo
-w /etc/sudoers -p wa -k sudoers
-w /etc/sudoers.d/ -p wa -k sudoers

# Cron
-w /etc/crontab -p wa -k cron
-w /var/spool/cron/ -p wa -k cron

# Benutzeränderungen
-w /etc/passwd -p wa -k user_change
-w /etc/shadow -p wa -k user_change
-w /etc/group -p wa -k group_change

# Regeln anzeigen
sudo auditctl -l

# Audits für einen Key suchen
sudo ausearch -k sshd_config --interpret

# Audit-Report erstellen
sudo aureport --auth

sudo apt install aide -y

# Datenbank initialisieren
sudo aideinit

# Neue Datenbank verschieben
sudo cp /var/lib/aide/aide.db.new /var/lib/aide/aide.db

sudo nano /etc/cron.d/aide-check

# Täglicher Check um 03:00
0 3 * * * root /usr/bin/aide --check | mail -s "AIDE Report" admin@example.com

# Manuellen Check durchführen
sudo aide --check

# Erwartete Ausgabe bei sauberem System:
# AIDE found NO differences between database and filesystem.

# Automatische Updates und Neustart-Prüfer installieren
sudo apt install unattended-upgrades needrestart -y

# Konfiguration aktivieren
sudo dpkg-reconfigure -plow unattended-upgrades

// Nur Sicherheitsupdates automatisch installieren
Unattended-Upgrade::Allowed-Origins {
    "${distro_id}:${distro_codename}-security";
};

// Automatisch verwaiste Abhängigkeiten entfernen
Unattended-Upgrade::Remove-Unused-Dependencies "true";

// Automatischer Neustart bei Kernel-Updates um 04:00 Uhr
Unattended-Upgrade::Automatic-Reboot "true";
Unattended-Upgrade::Automatic-Reboot-Time "04:00";

# Testlauf ohne Änderungen durchführen (Dry-Run)
sudo unattended-upgrade --dry-run --debug

sudo aa-status

apparmor module is loaded.
XX profiles are in enforce mode.
0 processes are unconfined but have a profile defined.

# Profile aktivieren und strikt erzwingen
sudo apt install apparmor-utils -y
sudo aa-enforce /etc/apparmor.d/*

# Aktuelle Tabellen anzeigen
sudo nft list ruleset

table inet filter {
    chain input {
        type filter hook input priority filter; policy drop;
        # Regeln hier
    }
    chain forward {
        type filter hook forward priority filter; policy drop;
    }
    chain output {
        type filter hook output priority filter; policy accept;
    }
}

sudo nano /etc/nftables.conf

#!/usr/sbin/nft -f

flush ruleset

table inet filter {
    chain input {
        type filter hook input priority filter; policy drop;

        # Erlaube etablierte Verbindungen
        ct state established,related accept

        # Erlaube Loopback
        iif lo accept

        # Erlaube ICMP (Ping)
        ip protocol icmp accept
        ip6 nexthdr icmpv6 accept

        # Erlaube SSH (Port 22)
        tcp dport 22 accept

        # Erlaube HTTP/HTTPS (falls Webserver)
        tcp dport { 80, 443 } accept

        # Logging für abgelehnten Traffic
        log prefix "nft-drop: " counter drop
    }

    chain forward {
        type filter hook forward priority filter; policy drop;
    }

    chain output {
        type filter hook output priority filter; policy accept;
    }
}

sudo systemctl enable nftables
sudo systemctl start nftables

# SSH-Rate-Limit: Maximal 5 Verbindungen pro Minute
sudo nft add rule inet filter input tcp dport 22 meter ssh-rate { limit rate 5/minute burst 5 packets } accept

# Aktive Regeln prüfen
sudo nft list ruleset

# Verbindungen prüfen
sudo ss -tulnp | grep -E "22|80|443"

# Drops in Logs prüfen
sudo journalctl -k | grep "nft-drop"

# CrowdSec-spezifische Chains anzeigen
sudo nft list chain inet crowdsec-crowdsec-block

table inet crowdsec-crowdsec {
    chain crowdsec-block {
        type filter hook input priority filter; policy accept;
        ip saddr @crowdsec-blacklist-jump drop
        ip6 saddr @crowdsec-blacklist6-jump drop
    }
}

┌─────────────────────────────────────────────────────────────┐
│                    Firewall Traffic-Flow                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   [Eingehender Traffic]                                     │
│          │                                                  │
│          ▼                                                  │
│   ┌──────────────────┐                                      │
│   │  CrowdSec Check  │  ◀── Whitelist? ──▶ ACCEPT           │
│   │  (blacklist)     │  ◀── Ban? ────────▶ DROP + LOG       │
│   └────────┬─────────┘                                      │
│            │                                                │
│            ▼                                                │
│   ┌──────────────────┐                                      │
│   │  Firewall Rules  │  ◀── SSH/HTTP ────▶ ACCEPT           │
│   │  (nftables)      │  ◀── Rest ────────▶ DROP             │
│   └────────┬─────────┘                                      │
│            │                                                │
│            ▼                                                │
│   ┌──────────────────┐                                      │
│   │  CrowdSec Agent  │  ◀── Logs analysieren                │
│   │  (Log-Analyse)   │  ◀── Decisions erstellen             │
│   └──────────────────┘                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# Certbot installieren
sudo apt install certbot -y

# Zertifikat anfordern (Nginx)
sudo certbot --nginx -d example.com

# Zertifikat anfordern (Apache)
sudo certbot --apache -d example.com

sudo nano /etc/nginx/snippets/ssl-params.conf

ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:10m;
ssl_session_tickets off;

# OCSP Stapling
ssl_stapling on;
ssl_stapling_verify on;

# Security Headers
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains" always;
add_header X-Content-Type-Options nosniff always;
add_header X-Frame-Options DENY always;

# Cron-Job für automatische Erneuerung
sudo crontab -e

# Täglich um 02:30, Zertifikat bei Bedarf erneuern
30 2 * * * certbot renew --quiet --post-hook "systemctl reload nginx"

# TLS-Konfiguration testen
openssl s_client -connect example.com:443 -tls1_3

# Zertifikats-Details prüfen
echo | openssl s_client -connect example.com:443 2>/dev/null | openssl x509 -noout -dates

sudo apt install unbound -y

sudo nano /etc/unbound/unbound.conf.d/hardening.conf

server:
    interface: 127.0.0.1
    access-control: 127.0.0.0/8 allow

    # DNSSEC aktivieren
    auto-trust-anchor-file: /var/lib/unbound/root.key

    # Datenschutz
    hide-identity: yes
    hide-version: yes

    # Performance
    msg-cache-slabs: 8
    rrset-cache-slabs: 8
    infra-cache-slabs: 8
    key-cache-slabs: 8

forward-zone:
    name: "."
    forward-addr: 1.1.1.1@853#cloudflare-dns.com
    forward-addr: 9.9.9.9@853#dns.quad9.net
    forward-tls-upstream: yes

sudo systemctl enable unbound
sudo systemctl start unbound

# DNS-Auflösung testen
dig example.com @127.0.0.1

# DNSSEC-Test
dig dnssec-failed.org @127.0.0.1
# Erwartung: SERVFAIL (DNSSEC-Breaker korrekt erkannt)

# DNS-over-HTTPS testen
curl -v https://cloudflare-dns.com/dns-query?name=example.com 2>&1 | grep "HTTP/2"

mkdir -p ~/ansible-hardening/{roles,inventory,group_vars}

nano ~/ansible-hardening/inventory/hosts.ini

[production]
server1 ansible_host=192.168.1.100
server2 ansible_host=192.168.1.101

[homelab]
server3 ansible_host=192.168.10.50

[all:vars]
ansible_user=admin
ansible_python_interpreter=/usr/bin/python3

nano ~/ansible-hardening/hardening.yml

---
- name: Linux Server Härtung
  hosts: all
  become: yes
  vars:
    ssh_port: 22
    allowed_users:
      - admin
    enable_crowdsec: true
    enable_aide: true

  tasks:
    # System-Updates
    - name: System aktualisieren
      apt:
        update_cache: yes
        upgrade: dist

    # SSH-Härtung
    - name: SSH-Konfiguration härten
      lineinfile:
        path: /etc/ssh/sshd_config
        regexp: "{{ item.regexp }}"
        line: "{{ item.line }}"
      loop:
        - { regexp: '^#?PermitRootLogin', line: 'PermitRootLogin no' }
        - { regexp: '^#?PasswordAuthentication', line: 'PasswordAuthentication no' }
        - { regexp: '^#?MaxAuthTries', line: 'MaxAuthTries 3' }
        - { regexp: '^#?LoginGraceTime', line: 'LoginGraceTime 30' }
      notify: sshd neu starten

    # Sysctl-Härtung
    - name: Sysctl-Parameter setzen
      sysctl:
        name: "{{ item.name }}"
        value: "{{ item.value }}"
        state: present
        reload: yes
      loop:
        - { name: 'net.ipv4.conf.all.rp_filter', value: '1' }
        - { name: 'net.ipv4.conf.all.accept_redirects', value: '0' }
        - { name: 'kernel.randomize_va_space', value: '2' }
        - { name: 'kernel.dmesg_restrict', value: '1' }

    # Unnötige Services
    - name: Unnötige Services deaktivieren
      systemd:
        name: "{{ item }}"
        state: stopped
        enabled: no
        masked: yes
      loop:
        - cups
        - bluetooth
        - avahi-daemon

    # Audit-Logging
    - name: Auditd installieren
      apt:
        name: auditd
        state: present

    - name: Audit-Regeln deployen
      copy:
        src: files/audit-rules.rules
        dest: /etc/audit/rules.d/hardening.rules
      notify: auditd neu starten

  handlers:
    - name: sshd neu starten
      systemd:
        name: sshd
        state: restarted

    - name: auditd neu starten
      systemd:
        name: auditd
        state: restarted

cd ~/ansible-hardening
ansible-playbook -i inventory/hosts.ini hardening.yml

# Prüfe ob alle Server erreichbar sind
ansible all -i inventory/hosts.ini -m ping

# SSH-Konfiguration prüfen
ansible all -i inventory/hosts.ini -m shell -a "sshd -T | grep permitrootlogin"

server1 | CHANGED | rc=0 >>
permitrootlogin no

server2 | CHANGED | rc=0 >>
permitrootlogin no

sudo apt install libopenscap8 scap-security-guide -y

# Verfügbare Profiles anzeigen
oscap info /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml | grep "Profile"

# CIS-Level-1-Scan
sudo oscap xccdf eval \
    --profile cis_level1_server \
    --results cis-results.xml \
    --report cis-report.html \
    /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

# Report auf den lokalen Rechner kopieren und öffnen
scp admin@server:/tmp/cis-report.html ~/Desktop/

# Nur wenn du die Auswirkungen verstehst
sudo oscap xccdf generate fix \
    --profile cis_level1_server \
    --fix-type ansible \
    --output cis-remediation.yml \
    /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

# Score prüfen
oscap xccdf generate report cis-results.xml > /dev/null
grep -E "score|pass|fail" cis-results.xml | tail -10