NGINX-Seite: Sichtbarkeit/Kontrolle der automatischen Let's-Encrypt-Verlaengerung

certbot richtet die automatische Verlaengerung (certbot.timer, zweimal
taeglich) zwar schon beim Paket-Install selbst ein -- das war fuer den
Admin in der Weboberflaeche bisher aber unsichtbar, reine Behauptung im
Code-Kommentar. Jetzt sichtbar/nachpruefbar:

- Neue Zeile "Automatische Verlaengerung" im Zertifikat-Status (nur bei
  Let's-Encrypt-Zertifikaten): Timer aktiv/inaktiv + naechster geplanter
  Lauf (_certbot_timer_status(), liest systemctl is-active/list-timers).
- "Verlaengerung testen (Dry-Run)" -- certbot renew --dry-run, aendert
  nichts, zeigt nur ob die Verlaengerung im Ernstfall funktionieren wuerde.
- "Jetzt manuell verlaengern" -- certbot renew --force-renewal, fuer
  Testzwecke oder eine sofortige Schluessel-Rotation (mit Warnhinweis auf
  Let's Encrypts Rate-Limits).
- Hinweistext beim Anfordern zeigt den Timer-Status schon VOR der ersten
  Anforderung.

VERSION 1.0.7 -> 1.0.8 (ab hier wieder normale fortlaufende
Versionierung statt erneutem Release derselben Versionsnummer).

Live auf Testsystem-Update-Restart verifiziert: Seite laedt weiterhin
fehlerfrei (_certbot_timer_status crasht nicht ohne aktives
Let's-Encrypt-Zertifikat), certbot.timer selbst bestaetigt aktiv
(naechster Lauf laut systemctl list-timers korrekt angezeigt).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

etc/systemd/system/tesm.service

@@ -14,8 +14,12 @@ WorkingDirectory=/srv/tesm
 # nach 30s auch bei einer offenen, aber gerade inaktiven SSH-Terminal-
 # WebSocket-Verbindung und würde den Worker (und damit JEDE Verbindung,
 # da nur ein Prozess läuft) killen.
+# "--bind 127.0.0.1:5000" statt 0.0.0.0: Flask/Gunicorn soll ausschließlich
+# über den nginx-Reverse-Proxy (siehe Einstellungen -> NGINX) erreichbar
+# sein, nicht zusätzlich direkt und unverschlüsselt über Port 5000 aus dem
+# Netz -- nginx selbst greift ohnehin nur über 127.0.0.1 zu.
 ExecStart=/srv/tesm/venv/bin/gunicorn --workers 1 --worker-class gthread --threads 16 \
-    --timeout 0 --bind 0.0.0.0:5000 app:app
+    --timeout 0 --bind 127.0.0.1:5000 app:app
 Restart=always
 RestartSec=5
 

install.sh

@@ -44,6 +44,21 @@ NC='\033[0m'
 print_status() { echo -e "${GREEN}✔${NC} ${1} completed."; }
 step()         { echo -e "${RED}→${NC} ${1}..." | tee -a /var/log/tesm-install.log; }
 
+# Kopiert nur, wenn der Inhalt sich tatsächlich unterscheidet (oder das
+# Ziel noch fehlt) -- bei einem Update sollen ausschließlich Dateien
+# angefasst werden, die sich zwischen der laufenden und der neuen Version
+# wirklich geändert haben (unverändert lässt "cp" Zeitstempel/Inode aber
+# trotzdem hochzählen, was z.B. Monitoring/Backups unnötig triggert).
+# Gibt 0 zurück, wenn tatsächlich kopiert wurde, 1 wenn übersprungen.
+install_if_changed() {
+    local src="$1" dst="$2" mode="${3:-644}"
+    if [ -f "$dst" ] && cmp -s "$src" "$dst"; then
+        return 1
+    fi
+    sudo install -m "$mode" "$src" "$dst"
+    return 0
+}
+
 # "clear" schlägt ohne TERM/Pseudo-Terminal fehl (z.B. bei Automatisierung
 # per SSH exec_command ohne pty, genau wie update.sh dieses Skript aufruft)
 # -- mit "set -e" bricht das sonst die GESAMTE Installation sofort und ohne
@@ -99,7 +114,7 @@ fi
 # ---- Pakete ----
 step "Installing system packages"
 sudo apt-get update >>/var/log/tesm-install.log 2>&1 && print_status "apt update"
-sudo apt-get install -y python3 python3-venv python3-pip nginx sqlite3 expect openssh-client git rsync iputils-ping logrotate >>/var/log/tesm-install.log 2>&1 && print_status "Packages installed"
+sudo apt-get install -y python3 python3-venv python3-pip nginx sqlite3 expect openssh-client git rsync iputils-ping logrotate certbot >>/var/log/tesm-install.log 2>&1 && print_status "Packages installed"
 
 # ---- Log-Verzeichnis ----
 # NICHT weltweit beschreibbar (0755 reicht) -- sowohl tesm.service als
@@ -150,10 +165,13 @@ fi
 # ---- Custom-Skripte + systemd ----
 step "Copying custom scripts and systemd units"
 sudo mkdir -p /usr/local/bin/custom
-sudo cp "$REPO_DIR/usr/local/bin/custom/poe.sh" /usr/local/bin/custom/poe.sh
-sudo chmod +x /usr/local/bin/custom/poe.sh
-sudo cp "$REPO_DIR"/etc/systemd/system/*.service /etc/systemd/system/
-sudo cp "$REPO_DIR"/etc/systemd/system/*.timer /etc/systemd/system/
+UNITS_CHANGED=0
+install_if_changed "$REPO_DIR/usr/local/bin/custom/poe.sh" /usr/local/bin/custom/poe.sh 755 || true
+for f in "$REPO_DIR"/etc/systemd/system/*.service "$REPO_DIR"/etc/systemd/system/*.timer; do
+    if install_if_changed "$f" "/etc/systemd/system/$(basename "$f")" 644; then
+        UNITS_CHANGED=1
+    fi
+done
 print_status "Scripts and units copied"
 
 # ---- SSH-Login-Banner (MOTD) ----
@@ -162,8 +180,7 @@ print_status "Scripts and units copied"
 # Die Standard-Skripte bleiben erhalten, werden aber deaktiviert (chmod -x,
 # nicht gelöscht), damit ein Rückbau jederzeit per chmod +x möglich ist.
 step "Setting up TESM SSH login banner"
-sudo cp "$REPO_DIR/etc/update-motd.d/50-tesm" /etc/update-motd.d/50-tesm
-sudo chmod 755 /etc/update-motd.d/50-tesm
+install_if_changed "$REPO_DIR/etc/update-motd.d/50-tesm" /etc/update-motd.d/50-tesm 755 || true
 sudo chmod -x /etc/update-motd.d/00-header /etc/update-motd.d/10-help-text \
     /etc/update-motd.d/50-motd-news /etc/update-motd.d/60-unminimize \
     /etc/update-motd.d/91-release-upgrade /etc/update-motd.d/92-unattended-upgrades \
@@ -171,8 +188,16 @@ sudo chmod -x /etc/update-motd.d/00-header /etc/update-motd.d/10-help-text \
 print_status "SSH login banner configured"
 
 # ---- nginx ----
+# Nur bei einer Frischinstallation aus dem Repo-Template geschrieben --
+# eine bereits vorhandene Konfiguration (egal ob unverändert oder von der
+# App selbst z.B. um SSL/HSTS erweitert, siehe Systemeinstellungen -> SSL)
+# wird NIE wieder überschrieben. Symlink/Default-Site-Entfernung und der
+# Validierungs-Reload laufen dagegen immer -- rein idempotent, ändern an
+# einer bestehenden Konfiguration selbst nichts.
 step "Configuring nginx reverse proxy"
-sudo cp "$REPO_DIR/etc/nginx/sites-available/tesm" /etc/nginx/sites-available/tesm
+if [ ! -f /etc/nginx/sites-available/tesm ]; then
+    sudo cp "$REPO_DIR/etc/nginx/sites-available/tesm" /etc/nginx/sites-available/tesm
+fi
 sudo ln -sf /etc/nginx/sites-available/tesm /etc/nginx/sites-enabled/tesm
 sudo rm -f /etc/nginx/sites-enabled/default
 sudo nginx -t >>/var/log/tesm-install.log 2>&1 && sudo systemctl reload nginx
@@ -180,7 +205,9 @@ print_status "nginx configured"
 
 # ---- Dienste aktivieren ----
 step "Enabling services"
-sudo systemctl daemon-reload
+if [ "$UNITS_CHANGED" -eq 1 ]; then
+    sudo systemctl daemon-reload
+fi
 sudo systemctl enable --now tesm.service
 sudo systemctl enable --now tesm-check.service tesm-check-restart.timer
 print_status "Services enabled and started"

srv/tesm/VERSION

@@ -1 +1 @@
-1.0.6
+1.0.8

srv/tesm/app.py

@@ -16,7 +16,8 @@ from simple_websocket.errors import ConnectionClosed
 from werkzeug.utils import secure_filename
 from cryptography.fernet import Fernet
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
-from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography import x509
 from datetime import datetime, timedelta
 import base64, csv, ipaddress, logging, shlex, shutil, socket, sqlite3, glob, json, os, re, secrets, stat, subprocess, threading, time, traceback
 import paramiko
@@ -107,6 +108,51 @@ except OSError:
 SWITCH_DEFAULT_SSH_PORT = 22
 ALLOWED_AVATAR_EXT = {"png", "jpg", "jpeg", "gif", "webp"}
 
+NGINX_SITE_CONFIG_PATH = os.environ.get("TESM_NGINX_CONFIG", "/etc/nginx/sites-available/tesm")
+TESM_SSL_DIR = os.environ.get("TESM_SSL_DIR", "/etc/tesm/ssl")
+TESM_SSL_CERT_PATH = os.path.join(TESM_SSL_DIR, "cert.pem")
+TESM_SSL_KEY_PATH = os.path.join(TESM_SSL_DIR, "key.pem")
+TESM_ACME_WEBROOT = os.environ.get("TESM_ACME_WEBROOT", "/var/www/tesm-acme")
+CERTBOT_DEPLOY_HOOK_PATH = "/etc/letsencrypt/renewal-hooks/deploy/tesm-reload-nginx.sh"
+try:
+    # Bewusst AUSSERHALB von /srv/tesm -- das rsync --delete beim Deployen
+    # (siehe install.sh) würde ein dort abgelegtes Zertifikat sonst bei
+    # jedem Update wieder löschen. Analog zu /etc/nginx/ selbst: liegt
+    # außerhalb des App-Verzeichnisses, übersteht also jedes Update.
+    os.makedirs(TESM_SSL_DIR, exist_ok=True)
+    os.chmod(TESM_SSL_DIR, 0o700)
+    os.makedirs(TESM_ACME_WEBROOT, exist_ok=True)
+except OSError:
+    pass
+
+
+def _le_cert_path(domain):
+    return f"/etc/letsencrypt/live/{domain}/fullchain.pem"
+
+
+def _le_key_path(domain):
+    return f"/etc/letsencrypt/live/{domain}/privkey.pem"
+
+
+def _write_certbot_deploy_hook():
+    """certbot führt nach JEDER erfolgreichen Erneuerung (egal für welche
+    Domain) automatisch alle ausführbaren Skripte in diesem Verzeichnis aus
+    -- ohne diesen Hook würde nginx nach einer automatischen Verlängerung
+    weiter das alte (bald ablaufende) Zertifikat verwenden, da es die
+    Datei nicht von selbst neu einliest. Läuft wie _write_logrotate_config
+    bei jedem App-Start neu, damit ein frisch installiertes certbot den
+    Hook auch ohne manuellen Aufruf der NGINX-Seite bekommt."""
+    try:
+        os.makedirs(os.path.dirname(CERTBOT_DEPLOY_HOOK_PATH), exist_ok=True)
+        with open(CERTBOT_DEPLOY_HOOK_PATH, "w", encoding="utf-8") as f:
+            f.write("#!/bin/bash\nsystemctl reload nginx\n")
+        os.chmod(CERTBOT_DEPLOY_HOOK_PATH, 0o755)
+    except OSError:
+        pass
+
+
+_write_certbot_deploy_hook()
+
 CREDENTIAL_CATEGORIES = [
     ("switch", "Switch"),
     ("linux", "Linux-Client"),
@@ -260,6 +306,10 @@ PERMISSIONS = {
                 "label": "LDAP",
                 "rows": {"view": "settings_ldap.view", "edit": "settings_ldap.edit"},
             },
+            "settings_nginx": {
+                "label": "NGINX",
+                "rows": {"view": "settings_nginx.view", "edit": "settings_nginx.edit"},
+            },
             "papierkorb": {
                 "label": "Papierkorb",
                 "rows": {"view": "papierkorb.view", "edit": "papierkorb.edit"},
@@ -298,6 +348,8 @@ PERMISSION_LABELS = {
     "settings_dhcp.edit": "DHCP-Konfiguration speichern und Reservierungsdatei schreiben",
     "settings_ldap.view": "LDAP/AD-Konfiguration lesen",
     "settings_ldap.edit": "LDAP/AD-Konfiguration speichern (Bind-Konto, Gruppenzuordnungen)",
+    "settings_nginx.view": "NGINX-Konfiguration und Zertifikatsstatus lesen",
+    "settings_nginx.edit": "NGINX-Konfiguration ändern (Domain/Ports, Zertifikat hochladen oder per Let's Encrypt anfordern, HTTPS/HSTS aktivieren)",
 }
 
 ALL_PERMISSION_KEYS = []
@@ -337,6 +389,7 @@ NAV_ITEMS = [
         {"key": "settings_ldap", "label": "LDAP", "icon": "users", "endpoint": "settings_ldap"},
         {"key": "settings_dhcp", "label": "DHCP", "icon": "network", "endpoint": "settings_dhcp"},
         {"key": "settings_importexport", "label": "Im-/Export", "icon": "transfer", "endpoint": "settings_import_export"},
+        {"key": "settings_nginx", "label": "NGINX", "icon": "server", "endpoint": "settings_nginx"},
         {"key": "papierkorb", "label": "Papierkorb", "icon": "trash", "endpoint": "papierkorb"},
     ]},
     {"key": "logs_group", "label": "Logs", "icon": "terminal", "children": [
@@ -375,6 +428,8 @@ def _nav_key_visible(key, user):
         return user.can_view_settings_dhcp
     if key == "settings_ldap":
         return user.can_view_settings_ldap
+    if key == "settings_nginx":
+        return user.has_permission("settings_nginx.view")
     if key == "logs_live":
         return user.can_view_live_log
     if key == "logs_history":
@@ -1904,18 +1959,39 @@ def _format_log_size(num_bytes):
 
 
 _LOG_HISTORY_FILE_RE = re.compile(r"^live\.log\.([1-9][0-9]*)$")
+_LOG_HISTORY_DATE_FMT = "%d.%m.%Y %H:%M"
 
 
 def _live_log_history_files():
-    """Ältere, von logrotate rotierte Kopien des Live-Logs (live.log.1 =
-    zuletzt rotiert, .2 der Lauf davor, usw. -- copytruncate ohne compress,
-    siehe _write_logrotate_config, daher reine Textdateien ohne .gz),
-    sortiert von neu (1) nach alt."""
+    """Alle über die Verlauf-Seite auswählbaren Stände des Live-Logs --
+    generation 0 ist die aktuelle, noch laufende live.log selbst, 1 die
+    zuletzt rotierte Kopie, 2 der Lauf davor usw. (copytruncate ohne
+    compress, siehe _write_logrotate_config, daher reine Textdateien ohne
+    .gz), sortiert von neu (0) nach alt.
+
+    Jede Kopie deckt den Zeitraum zwischen ZWEI Rotationen ab: ihr eigenes
+    mtime ist der Zeitpunkt, an dem ihr Inhalt eingefroren wurde (Ende des
+    Zeitraums), das mtime der NÄCHSTälteren Generation der Beginn -- ein
+    reines rename() bei jeder weiteren Rotation ändert mtime nicht, jede
+    Generation behält also dauerhaft den Zeitpunkt ihrer eigenen
+    Entstehung. Für die aktuelle live.log gibt es kein eigenes "Ende",
+    dort wird stattdessen "laufend" angezeigt."""
     results = []
+    try:
+        if os.path.isfile(TESM_LIVE_LOG_PATH):
+            mtime = os.path.getmtime(TESM_LIVE_LOG_PATH)
+            size = os.path.getsize(TESM_LIVE_LOG_PATH)
+            results.append({
+                "filename": "live.log", "generation": 0,
+                "mtime": mtime, "size_str": _format_log_size(size),
+            })
+    except OSError:
+        pass
+
     try:
         entries = os.listdir(TESM_LOG_DIR)
     except OSError:
-        return results
+        entries = []
     for entry in entries:
         m = _LOG_HISTORY_FILE_RE.match(entry)
         if not m:
@@ -1929,20 +2005,30 @@ def _live_log_history_files():
         except OSError:
             continue
         results.append({
-            "filename": entry,
-            "generation": int(m.group(1)),
-            "mtime_str": datetime.fromtimestamp(mtime).strftime("%d.%m.%Y %H:%M"),
-            "size_str": _format_log_size(size),
+            "filename": entry, "generation": int(m.group(1)),
+            "mtime": mtime, "size_str": _format_log_size(size),
         })
     results.sort(key=lambda r: r["generation"])
+
+    for i, entry in enumerate(results):
+        older = results[i + 1] if i + 1 < len(results) else None
+        start_str = datetime.fromtimestamp(older["mtime"]).strftime(_LOG_HISTORY_DATE_FMT) if older else None
+        if entry["generation"] == 0:
+            end_str = "laufend"
+        else:
+            end_str = datetime.fromtimestamp(entry["mtime"]).strftime(_LOG_HISTORY_DATE_FMT)
+        entry["range_label"] = f"{start_str or '?'} – {end_str}"
     return results
 
 
 def _resolve_log_history_file(filename):
     """Validiert einen vom Client übergebenen Dateinamen (?file=...) gegen
-    die tatsächlich vorhandenen rotierten Live-Log-Kopien in TESM_LOG_DIR --
-    verhindert Path-Traversal bzw. beliebiges Datei-Lesen über den
-    Query-Parameter. Gibt den vollen Pfad oder None zurück."""
+    die tatsächlich vorhandene aktuelle live.log bzw. rotierte Kopien davon
+    in TESM_LOG_DIR -- verhindert Path-Traversal bzw. beliebiges
+    Datei-Lesen über den Query-Parameter. Gibt den vollen Pfad oder None
+    zurück."""
+    if filename == "live.log":
+        return TESM_LIVE_LOG_PATH if os.path.isfile(TESM_LIVE_LOG_PATH) else None
     if not filename or not _LOG_HISTORY_FILE_RE.match(filename):
         return None
     full_path = os.path.join(TESM_LOG_DIR, filename)
@@ -2463,6 +2549,511 @@ def _revert_network_config(token):
         _pending_network_revert.pop(token, None)
 
 
+# ============================================================================
+# NGINX (Systemeinstellungen -> NGINX)
+# Verwaltet den kompletten Reverse-Proxy: Domain/Ports, SSL/HSTS,
+# Zertifikat (Upload ODER Let's Encrypt).
+#
+# Let's Encrypt läuft bewusst über "certbot certonly --webroot", NICHT über
+# das certbot-nginx-Plugin -- das Plugin würde NGINX_SITE_CONFIG_PATH
+# direkt editieren (eigene server-Blöcke/Zeilen einfügen) und diese
+# Änderungen bei der nächsten Änderung über diese Seite (die die Datei
+# komplett neu schreibt, siehe _render_nginx_config) wieder verlieren.
+# Mit der webroot-Methode bleibt _render_nginx_config die EINZIGE Quelle
+# für den Datei-Inhalt; certbot legt nur Dateien unter TESM_ACME_WEBROOT
+# ab und liest/schreibt sein Zertifikat unter /etc/letsencrypt/live/.
+# ============================================================================
+
+NGINX_REVERT_SECONDS = 45
+_pending_nginx_revert = {}
+
+_DOMAIN_RE = re.compile(r"^(?=.{1,253}$)([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$")
+
+
+def _valid_server_name(name):
+    """"_" (nginx-Catch-all, kein bestimmter Hostname -- Standard für rein
+    interne Instanzen ohne eigene Domain) oder eine plausibel geformte
+    FQDN."""
+    return name == "_" or bool(_DOMAIN_RE.match(name))
+
+
+def _valid_port(value):
+    try:
+        n = int(value)
+    except (TypeError, ValueError):
+        return False
+    return 1 <= n <= 65535 and n != 5000
+
+
+_NGINX_PROXY_LOCATIONS = """    location /ws/ {
+        proxy_pass http://127.0.0.1:5000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection $connection_upgrade;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 3600s;
+        proxy_send_timeout 3600s;
+    }
+
+    location / {
+        proxy_pass http://127.0.0.1:5000;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location /static/ {
+        alias /srv/tesm/static/;
+        expires 7d;
+    }
+"""
+
+
+def _render_nginx_config(server_name, http_port, https_port, ssl_enabled, hsts_enabled, cert_path, key_path):
+    """Erzeugt den kompletten Inhalt von NGINX_SITE_CONFIG_PATH. Die
+    Reverse-Proxy-Regeln (WebSocket-Terminal, Haupt-App, statische Dateien)
+    sind bei aktivem SSL identisch, nur hinter einem HTTPS-Block mit
+    Zertifikat/HSTS statt direkt hinter dem HTTP-Port -- der HTTP-Port
+    leitet dann nur noch auf https weiter, damit ein alter Bookmark/Link
+    nicht plötzlich ins Leere läuft. Die ACME-Challenge-Location wird
+    IMMER mitgeschrieben (auch ohne aktives SSL) -- eine Let's-Encrypt-
+    (Erst-)Anforderung braucht sie schon VOR dem ersten SSL-Aktivieren,
+    eine Verlängerung später ebenso. ACME HTTP-01 verbindet sich immer auf
+    Port 80 (protokollbedingt, nicht konfigurierbar) -- weicht der
+    eingestellte HTTP-Port davon ab, wird zusätzlich ein minimaler, nur
+    dafür zuständiger Port-80-Block ergänzt, damit Let's Encrypt trotzdem
+    funktioniert."""
+    header = 'map $http_upgrade $connection_upgrade {\n    default upgrade;\n    "" close;\n}\n\n'
+    acme_location = (
+        "    location /.well-known/acme-challenge/ {\n"
+        f"        root {TESM_ACME_WEBROOT};\n"
+        "        try_files $uri =404;\n"
+        "    }\n\n"
+    )
+
+    extra_acme_block = ""
+    if str(http_port) != "80":
+        extra_acme_block = (
+            "server {\n    listen 80;\n    server_name _;\n\n"
+            + acme_location
+            + "    location / { return 404; }\n}\n\n"
+        )
+
+    if not ssl_enabled:
+        return (
+            header + extra_acme_block
+            + f"server {{\n    listen {http_port};\n    server_name {server_name};\n\n"
+            + acme_location
+            + _NGINX_PROXY_LOCATIONS
+            + "}\n"
+        )
+
+    hsts_line = ""
+    if hsts_enabled:
+        hsts_line = '    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;\n\n'
+    redirect_target = "https://$host$request_uri" if str(https_port) == "443" else f"https://$host:{https_port}$request_uri"
+    return (
+        header + extra_acme_block
+        + f"server {{\n    listen {http_port};\n    server_name {server_name};\n\n"
+        + acme_location
+        + f"    location / {{\n        return 301 {redirect_target};\n    }}\n"
+        + "}\n\n"
+        + f"server {{\n    listen {https_port} ssl;\n    server_name {server_name};\n\n"
+        + f"    ssl_certificate {cert_path};\n"
+        + f"    ssl_certificate_key {key_path};\n\n"
+        + hsts_line
+        + _NGINX_PROXY_LOCATIONS
+        + "}\n"
+    )
+
+
+def _current_cert_paths():
+    """(cert_path, key_path) je nach aktiver Zertifikatsquelle (Setting
+    ssl_source: "upload" oder "letsencrypt"), oder (None, None) wenn
+    keins vorhanden ist."""
+    if get_setting("ssl_source", "upload") == "letsencrypt":
+        domain = get_setting("nginx_server_name", "_")
+        cert, key = _le_cert_path(domain), _le_key_path(domain)
+        if os.path.isfile(cert) and os.path.isfile(key):
+            return cert, key
+        return None, None
+    if os.path.isfile(TESM_SSL_CERT_PATH) and os.path.isfile(TESM_SSL_KEY_PATH):
+        return TESM_SSL_CERT_PATH, TESM_SSL_KEY_PATH
+    return None, None
+
+
+def _apply_nginx_config(server_name, http_port, https_port, ssl_enabled, hsts_enabled):
+    """Schreibt die neue nginx-Konfiguration, validiert sie (nginx -t) und
+    lädt nginx erst danach neu -- schlägt Validierung ODER Reload fehl,
+    wird der vorherige Inhalt sofort wiederhergestellt (Selbstschutz gegen
+    einen Tippfehler/ein defektes Zertifikat, das sonst den kompletten
+    Reverse-Proxy lahmlegen würde). Gibt (ok, fehlermeldung, alter_inhalt)
+    zurück -- den alten Inhalt braucht der Aufrufer zusätzlich für das
+    zeitgesteuerte Rückroll-Sicherheitsnetz, siehe NGINX_REVERT_SECONDS."""
+    try:
+        with open(NGINX_SITE_CONFIG_PATH, encoding="utf-8") as f:
+            previous = f.read()
+    except OSError:
+        previous = None
+
+    cert_path = key_path = None
+    if ssl_enabled:
+        cert_path, key_path = _current_cert_paths()
+        if not cert_path:
+            return False, "Kein Zertifikat verfügbar.", previous
+
+    new_content = _render_nginx_config(server_name, http_port, https_port, ssl_enabled, hsts_enabled, cert_path, key_path)
+    try:
+        with open(NGINX_SITE_CONFIG_PATH, "w", encoding="utf-8") as f:
+            f.write(new_content)
+    except OSError as e:
+        return False, f"Konfiguration konnte nicht geschrieben werden: {e}", previous
+
+    ok, out = _dhcp_run_privileged(["nginx", "-t"], timeout=10)
+    if ok:
+        ok, out = _dhcp_run_privileged(["systemctl", "reload", "nginx"], timeout=10)
+
+    if not ok:
+        if previous is not None:
+            try:
+                with open(NGINX_SITE_CONFIG_PATH, "w", encoding="utf-8") as f:
+                    f.write(previous)
+                subprocess.run(["systemctl", "reload", "nginx"], capture_output=True, timeout=10)
+            except OSError:
+                pass
+        return False, out, previous
+
+    return True, "", previous
+
+
+def _revert_nginx_config(token):
+    """Timer-Callback analog zu _revert_network_config: keine Bestätigung
+    binnen NGINX_REVERT_SECONDS -> vorherige nginx-Konfiguration UND alle
+    zugehörigen Einstellungen (Domain, Ports, SSL, HSTS) wiederherstellen."""
+    entry = _pending_nginx_revert.get(token)
+    if not entry:
+        return
+    try:
+        if entry["previous"] is not None:
+            with open(NGINX_SITE_CONFIG_PATH, "w", encoding="utf-8") as f:
+                f.write(entry["previous"])
+            subprocess.run(["nginx", "-t"], capture_output=True, timeout=10)
+            subprocess.run(["systemctl", "reload", "nginx"], capture_output=True, timeout=10)
+        for key, value in entry["prev_settings"].items():
+            set_setting(key, value)
+        log_action_system("settings.nginx_revert", "nginx", "automatisch nach Timeout zurückgerollt")
+    except Exception as e:
+        app.logger.error("nginx auto-revert failed: %s", e)
+    finally:
+        _pending_nginx_revert.pop(token, None)
+
+
+def _parse_cert(cert_bytes):
+    """Lädt ein PEM-Zertifikat und liefert sowohl das cryptography-Objekt
+    (für den Schlüssel-Abgleich) als auch die für die UI relevanten Felder
+    (Subject, Aussteller, Ablaufdatum)."""
+    cert = x509.load_pem_x509_certificate(cert_bytes)
+    try:
+        not_after = cert.not_valid_after_utc.replace(tzinfo=None)
+    except AttributeError:
+        not_after = cert.not_valid_after
+    return cert, {
+        "subject": cert.subject.rfc4514_string(),
+        "issuer": cert.issuer.rfc4514_string(),
+        "not_after": not_after,
+    }
+
+
+def _validate_cert_key_pair(cert_bytes, key_bytes):
+    """Prüft ein hochgeladenes Zertifikat+Key-Paar VOR dem Speichern --
+    verhindert, dass ein kaputtes oder nicht zusammenpassendes Paar erst
+    beim tatsächlichen SSL-Aktivieren auffällt (mit dem entsprechenden
+    Ausfallrisiko für den Reverse-Proxy). Der Schlüssel-Abgleich
+    funktioniert algorithmus-unabhängig (RSA/EC/...), da nur die
+    öffentlichen Schlüssel als DER-Bytes verglichen werden, nicht
+    algorithmus-spezifische Felder. Gibt (ok, fehlermeldung, info-dict)
+    zurück."""
+    try:
+        cert, info = _parse_cert(cert_bytes)
+    except ValueError as e:
+        return False, f"Datei ist kein gültiges PEM-Zertifikat ({e}).", {}
+
+    if info["not_after"] < datetime.utcnow():
+        return False, f"Zertifikat ist bereits abgelaufen (gültig bis {info['not_after']:%d.%m.%Y}).", info
+
+    try:
+        private_key = serialization.load_pem_private_key(key_bytes, password=None)
+    except (ValueError, TypeError) as e:
+        return False, f"Datei ist kein gültiger, unverschlüsselter privater Schlüssel ({e}).", info
+
+    cert_pub = cert.public_key().public_bytes(serialization.Encoding.DER, serialization.PublicFormat.SubjectPublicKeyInfo)
+    key_pub = private_key.public_key().public_bytes(serialization.Encoding.DER, serialization.PublicFormat.SubjectPublicKeyInfo)
+    if cert_pub != key_pub:
+        return False, "Zertifikat und privater Schlüssel passen nicht zusammen.", info
+
+    return True, "", info
+
+
+def _current_cert_info():
+    """Für die NGINX-Seite: Status des aktuell aktiven Zertifikats (Upload
+    oder Let's Encrypt, je nach ssl_source) inkl. verbleibender
+    Gültigkeitsdauer."""
+    cert_path, _key_path = _current_cert_paths()
+    if not cert_path:
+        return None
+    try:
+        with open(cert_path, "rb") as f:
+            _, info = _parse_cert(f.read())
+        info["days_left"] = (info["not_after"] - datetime.utcnow()).days
+        info["source"] = get_setting("ssl_source", "upload")
+        return info
+    except (OSError, ValueError):
+        return None
+
+
+def _request_letsencrypt_cert(domain, email=None):
+    """Fordert per certbot (webroot-Methode, siehe TESM_ACME_WEBROOT) ein
+    Zertifikat für die angegebene Domain an. Setzt voraus, dass die Domain
+    öffentlich auf diesen Host auflöst UND Port 80 aus dem Internet
+    erreichbar ist (ACME HTTP-01) -- beides kann diese App nicht prüfen,
+    ein Fehlschlag hier liegt i.d.R. an der Netzwerk-/DNS-Situation, nicht
+    an TESM selbst. Automatische Verlängerung übernimmt certbots eigener
+    systemd-Timer/Cron (Standard-Paketverhalten unter Debian/Ubuntu), der
+    Deploy-Hook (_write_certbot_deploy_hook) lädt nginx danach neu."""
+    args = [
+        "certbot", "certonly", "--webroot", "-w", TESM_ACME_WEBROOT,
+        "-d", domain, "--non-interactive", "--agree-tos", "--cert-name", domain,
+    ]
+    args += ["--email", email] if email else ["--register-unsafely-without-email"]
+    return _dhcp_run_privileged(args, timeout=120)
+
+
+def _certbot_timer_status():
+    """Status von certbot.timer -- dem systemd-Timer, der die automatische
+    Verlängerung tatsächlich antreibt (Standard-Paketverhalten unter
+    Debian/Ubuntu, zweimal täglich). Rein informativ für die NGINX-Seite:
+    "automatische Verlängerung" soll für den Admin sichtbar/nachprüfbar
+    sein, nicht nur eine Behauptung im Quelltext bleiben. None, wenn
+    certbot (noch) nicht installiert ist."""
+    active_ok, active_out = _dhcp_run_privileged(["systemctl", "is-active", "certbot.timer"], timeout=5)
+    if not active_ok and "could not be found" in active_out.lower():
+        return None
+    next_run = None
+    ok, out = _dhcp_run_privileged(["systemctl", "list-timers", "certbot.timer", "--no-legend"], timeout=5)
+    if ok and out.strip():
+        parts = out.strip().split(None, 4)
+        if len(parts) >= 4:
+            next_run = " ".join(parts[0:4])
+    return {"active": active_out.strip() == "active", "next_run": next_run}
+
+
+@app.route("/settings/nginx/raw")
+@login_required
+def settings_nginx_raw():
+    """Komplette, unbearbeitete nginx-Konfiguration für das RAW-Popup --
+    gleiches Muster wie beim Live-Log (window.openRawLogModal)."""
+    if not current_user.has_permission("settings_nginx.view"):
+        return "Keine Berechtigung.", 403
+    try:
+        with open(NGINX_SITE_CONFIG_PATH, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+    except OSError as e:
+        content = f"Fehler beim Lesen der Konfiguration: {e}"
+    response = app.response_class(content, mimetype="text/plain")
+    response.headers["X-Log-Name"] = os.path.basename(NGINX_SITE_CONFIG_PATH)
+    return response
+
+
+@app.route("/settings/nginx", methods=["GET", "POST"])
+@login_required
+def settings_nginx():
+    if request.method == "GET" and not current_user.has_permission("settings_nginx.view"):
+        flash("Keine Berechtigung, die NGINX-Einstellungen anzusehen.", "danger")
+        return redirect(url_for("index"))
+
+    if request.method == "POST":
+        if not current_user.has_permission("settings_nginx.edit"):
+            flash("Keine Berechtigung, die NGINX-Einstellungen zu ändern.", "danger")
+            return redirect(url_for("settings_nginx"))
+
+        if "upload_cert" in request.form:
+            cert_file = request.files.get("cert_file")
+            key_file = request.files.get("key_file")
+            if not cert_file or not cert_file.filename or not key_file or not key_file.filename:
+                flash("Bitte sowohl Zertifikat (PEM) als auch privaten Schlüssel (PEM) auswählen.", "danger")
+            else:
+                cert_bytes = cert_file.read()
+                key_bytes = key_file.read()
+                ok, msg, info = _validate_cert_key_pair(cert_bytes, key_bytes)
+                if not ok:
+                    flash(f"Zertifikat/Schlüssel nicht gespeichert: {msg}", "danger")
+                else:
+                    try:
+                        os.makedirs(TESM_SSL_DIR, exist_ok=True)
+                        with open(TESM_SSL_CERT_PATH, "wb") as f:
+                            f.write(cert_bytes)
+                        with open(TESM_SSL_KEY_PATH, "wb") as f:
+                            f.write(key_bytes)
+                        os.chmod(TESM_SSL_KEY_PATH, 0o600)
+                        os.chmod(TESM_SSL_CERT_PATH, 0o644)
+                        set_setting("ssl_source", "upload")
+                        log_action("settings.nginx_cert_upload", info.get("subject", ""), f"gültig bis {info['not_after']:%d.%m.%Y}")
+                        flash(
+                            f"Zertifikat gespeichert (Subject: {info.get('subject')}, gültig bis "
+                            f"{info['not_after']:%d.%m.%Y}). SSL ist damit noch nicht aktiviert -- unten aktivieren.",
+                            "success",
+                        )
+                    except OSError as e:
+                        flash(f"Zertifikat konnte nicht gespeichert werden: {e}", "danger")
+
+        elif "request_letsencrypt" in request.form:
+            domain = request.form.get("le_domain", "").strip()
+            email = request.form.get("le_email", "").strip() or None
+            if not domain or not _DOMAIN_RE.match(domain):
+                flash("Bitte eine gültige, öffentlich auflösbare Domain angeben.", "danger")
+            else:
+                ok, out = _request_letsencrypt_cert(domain, email)
+                if not ok:
+                    flash(f"Let's-Encrypt-Anforderung fehlgeschlagen: {out.strip()[-800:]}", "danger")
+                else:
+                    set_setting("ssl_source", "letsencrypt")
+                    set_setting("nginx_server_name", domain)
+                    log_action("settings.nginx_letsencrypt_request", domain, "Zertifikat erfolgreich ausgestellt")
+                    flash(
+                        f"Let's-Encrypt-Zertifikat für {domain} ausgestellt (automatische Verlängerung läuft über "
+                        f"certbots eigenen Timer). SSL ist damit noch nicht aktiviert -- unten aktivieren.",
+                        "success",
+                    )
+
+        elif "test_renewal" in request.form:
+            if get_setting("ssl_source", "upload") != "letsencrypt":
+                flash("Verlängerungs-Test setzt ein per Let's Encrypt ausgestelltes Zertifikat voraus.", "danger")
+            else:
+                domain = get_setting("nginx_server_name", "_")
+                ok, out = _dhcp_run_privileged(["certbot", "renew", "--dry-run", "--cert-name", domain], timeout=120)
+                if ok:
+                    log_action("settings.nginx_letsencrypt_test_renewal", domain)
+                    flash("Verlängerungs-Test erfolgreich (Dry-Run — es wurde nichts tatsächlich verändert).", "success")
+                else:
+                    flash(f"Verlängerungs-Test fehlgeschlagen: {out.strip()[-800:]}", "danger")
+
+        elif "force_renew" in request.form:
+            if get_setting("ssl_source", "upload") != "letsencrypt":
+                flash("Manuelle Verlängerung setzt ein per Let's Encrypt ausgestelltes Zertifikat voraus.", "danger")
+            else:
+                domain = get_setting("nginx_server_name", "_")
+                ok, out = _dhcp_run_privileged(["certbot", "renew", "--force-renewal", "--cert-name", domain], timeout=120)
+                if ok:
+                    log_action("settings.nginx_letsencrypt_force_renew", domain)
+                    flash("Zertifikat manuell erneuert — nginx wurde über den Deploy-Hook automatisch neu geladen.", "success")
+                else:
+                    flash(f"Manuelle Verlängerung fehlgeschlagen: {out.strip()[-800:]}", "danger")
+
+        elif "apply_nginx" in request.form:
+            new_server_name = request.form.get("server_name", "_").strip() or "_"
+            new_http_port = request.form.get("http_port", "80").strip()
+            new_https_port = request.form.get("https_port", "443").strip()
+            new_ssl = "ssl_enabled" in request.form
+            new_hsts = "hsts_enabled" in request.form
+
+            if not _valid_server_name(new_server_name):
+                flash("Ungültiger Domain-/Servername.", "danger")
+            elif not _valid_port(new_http_port) or not _valid_port(new_https_port):
+                flash("Port muss eine Zahl zwischen 1 und 65535 sein (5000 ist für die App selbst reserviert).", "danger")
+            elif new_http_port == new_https_port:
+                flash("HTTP- und HTTPS-Port müssen unterschiedlich sein.", "danger")
+            elif new_ssl and not _current_cert_paths()[0]:
+                flash("Kein Zertifikat verfügbar -- bitte zuerst hochladen oder per Let's Encrypt anfordern.", "danger")
+            elif new_hsts and not new_ssl:
+                flash("HSTS setzt aktives SSL voraus.", "danger")
+            else:
+                prev_settings = {
+                    "nginx_server_name": get_setting("nginx_server_name", "_"),
+                    "nginx_http_port": get_setting("nginx_http_port", "80"),
+                    "nginx_https_port": get_setting("nginx_https_port", "443"),
+                    "ssl_enabled": get_setting("ssl_enabled", "0"),
+                    "hsts_enabled": get_setting("hsts_enabled", "0"),
+                }
+                ok, err, previous = _apply_nginx_config(new_server_name, new_http_port, new_https_port, new_ssl, new_hsts)
+                if not ok:
+                    flash(f"nginx-Konfiguration konnte nicht angewendet werden, unverändert gelassen: {err}", "danger")
+                else:
+                    set_setting("nginx_server_name", new_server_name)
+                    set_setting("nginx_http_port", new_http_port)
+                    set_setting("nginx_https_port", new_https_port)
+                    set_setting("ssl_enabled", "1" if new_ssl else "0")
+                    set_setting("hsts_enabled", "1" if new_hsts else "0")
+                    log_action(
+                        "settings.nginx_apply", new_server_name,
+                        f"http={new_http_port} https={new_https_port} ssl={new_ssl} hsts={new_hsts}",
+                    )
+                    token = secrets.token_hex(8)
+                    timer = threading.Timer(NGINX_REVERT_SECONDS, _revert_nginx_config, args=(token,))
+                    timer.daemon = True
+                    _pending_nginx_revert.clear()
+                    _pending_nginx_revert[token] = {"timer": timer, "previous": previous, "prev_settings": prev_settings}
+                    timer.start()
+                    scheme = "https" if new_ssl else "http"
+                    port = new_https_port if new_ssl else new_http_port
+                    port_suffix = "" if port in ("80", "443") else f":{port}"
+                    flash(
+                        f"nginx-Konfiguration angewendet. Falls diese Seite jetzt noch über {scheme}{port_suffix} "
+                        f"erreichbar ist, bitte unten bestätigen — sonst wird nach {NGINX_REVERT_SECONDS}s "
+                        f"automatisch zurückgerollt.",
+                        "success",
+                    )
+
+        elif "confirm_nginx" in request.form:
+            token = request.form.get("confirm_nginx")
+            entry = _pending_nginx_revert.pop(token, None)
+            if entry:
+                entry["timer"].cancel()
+                log_action("settings.nginx_confirm", "nginx")
+                flash("nginx-Konfiguration bestätigt — kein automatisches Rollback mehr.", "success")
+            else:
+                flash("Keine ausstehende Bestätigung gefunden (evtl. bereits abgelaufen).", "danger")
+
+        elif "remove_cert" in request.form:
+            if get_setting("ssl_enabled", "0") == "1":
+                flash("Zertifikat kann nicht entfernt werden, solange SSL aktiv ist -- bitte zuerst deaktivieren.", "danger")
+            elif get_setting("ssl_source", "upload") == "letsencrypt":
+                domain = get_setting("nginx_server_name", "_")
+                ok, out = _dhcp_run_privileged(["certbot", "delete", "--cert-name", domain, "--non-interactive"], timeout=30)
+                if not ok:
+                    flash(f"Let's-Encrypt-Zertifikat konnte nicht entfernt werden: {out}", "danger")
+                else:
+                    log_action("settings.nginx_cert_remove", domain, "Let's Encrypt")
+                    flash("Let's-Encrypt-Zertifikat entfernt.", "success")
+            else:
+                for path in (TESM_SSL_CERT_PATH, TESM_SSL_KEY_PATH):
+                    try:
+                        os.remove(path)
+                    except OSError:
+                        pass
+                log_action("settings.nginx_cert_remove", "upload")
+                flash("Hochgeladenes Zertifikat entfernt.", "success")
+
+        return redirect(url_for("settings_nginx"))
+
+    pending_token = next(iter(_pending_nginx_revert), None)
+    return render_template(
+        "settings_nginx.html",
+        cert_info=_current_cert_info(),
+        ssl_enabled=get_setting("ssl_enabled", "0") == "1",
+        hsts_enabled=get_setting("hsts_enabled", "0") == "1",
+        server_name=get_setting("nginx_server_name", "_"),
+        http_port=get_setting("nginx_http_port", "80"),
+        https_port=get_setting("nginx_https_port", "443"),
+        pending_nginx_token=pending_token,
+        nginx_revert_seconds=NGINX_REVERT_SECONDS,
+        certbot_timer=_certbot_timer_status(),
+    )
+
+
 @app.route("/settings", methods=["GET", "POST"])
 @login_required
 def settings():
@@ -5901,7 +6492,8 @@ def logs_history():
     selected_name = requested if selected_path else None
     if not selected_path and files:
         selected_name = files[0]["filename"]
-        selected_path = os.path.join(TESM_LOG_DIR, selected_name)
+        selected_path = _resolve_log_history_file(selected_name)
+    selected_file = next((f for f in files if f["filename"] == selected_name), None)
 
     log_content = None
     total_lines = None
@@ -5913,7 +6505,7 @@ def logs_history():
             log_content = f"Fehler beim Lesen des Logs: {e}"
 
     return render_template(
-        "logs_history.html", files=files, selected_name=selected_name,
+        "logs_history.html", files=files, selected_name=selected_name, selected_file=selected_file,
         log_content=log_content, total_lines=total_lines, tail_lines=LIVE_LOG_TAIL_LINES,
     )
 

srv/tesm/templates/base.html

@@ -20,6 +20,8 @@
   "terminal": '<rect x="2" y="4" width="20" height="16" rx="2"/><path d="M6 9l4 3-4 3M13 15h5"/>',
   "history": '<path d="M3 12a9 9 0 109-9 9.75 9.75 0 00-6.74 2.74L3 8"/><path d="M3 3v5h5"/><path d="M12 7v5l4 2"/>',
   "clock": '<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 3"/>',
+  "shield": '<path d="M12 2l8 4v6c0 5-3.5 8.5-8 10-4.5-1.5-8-5-8-10V6z"/><path d="M9 12l2 2 4-4"/>',
+  "server": '<rect x="2" y="3" width="20" height="7" rx="1.5"/><rect x="2" y="14" width="20" height="7" rx="1.5"/><path d="M6 6.5h.01M6 17.5h.01"/>',
   "sliders": '<path d="M4 6h9M17 6h3M4 12h3M11 12h9M4 18h13M20 18h0"/><circle cx="15" cy="6" r="2"/><circle cx="9" cy="12" r="2"/><circle cx="17" cy="18" r="2"/>',
   "logout": '<path d="M9 21H5a2 2 0 01-2-2V5a2 2 0 012-2h4"/><path d="M16 17l5-5-5-5"/><path d="M21 12H9"/>',
   "gear": '<circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 00.33 1.82l.06.06a2 2 0 11-2.83 2.83l-.06-.06a1.65 1.65 0 00-1.82-.33 1.65 1.65 0 00-1 1.51V21a2 2 0 01-4 0v-.09A1.65 1.65 0 009 19.4a1.65 1.65 0 00-1.82.33l-.06.06a2 2 0 11-2.83-2.83l.06-.06A1.65 1.65 0 004.6 15a1.65 1.65 0 00-1.51-1H3a2 2 0 010-4h.09A1.65 1.65 0 004.6 9a1.65 1.65 0 00-.33-1.82l-.06-.06a2 2 0 112.83-2.83l.06.06A1.65 1.65 0 009 4.6a1.65 1.65 0 001-1.51V3a2 2 0 014 0v.09a1.65 1.65 0 001 1.51 1.65 1.65 0 001.82-.33l.06-.06a2 2 0 112.83 2.83l-.06.06A1.65 1.65 0 0019.4 9a1.65 1.65 0 001.51 1H21a2 2 0 010 4h-.09a1.65 1.65 0 00-1.51 1z"/>',

srv/tesm/templates/logs_history.html

@@ -1,14 +1,14 @@
 {% extends "base.html" %}
 {% set active_page = "logs" %}
 {% block page_title %}Verlauf{% endblock %}
-{% block page_sub %}<div class="topbar-sub">{{ selected_name or "kein Archiv-Log" }}</div>{% endblock %}
+{% block page_sub %}<div class="topbar-sub">{{ selected_file.range_label if selected_file else "kein Log" }}</div>{% endblock %}
 
 {% block content %}
 
 <div class="section-head">
   <div>
     <h2 style="font-size:16px;">Log-Verlauf</h2>
-    <div class="hint">Ältere, von logrotate rotierte Kopien des Live-Logs — {{ files|length }} Stand{{ 'e' if files|length != 1 else '' }} verfügbar.</div>
+    <div class="hint">Aktuelles Live-Log sowie ältere, von logrotate rotierte Kopien davon — {{ files|length }} Stand{{ 'e' if files|length != 1 else '' }} verfügbar, auswählbar nach Zeitraum. Aus Performance-Gründen unformatiert (RAW) dargestellt, ohne farbliche Aufbereitung.</div>
   </div>
   <div class="flex gap-2">
     <a href="{{ url_for('logs') }}" class="btn btn-secondary">
@@ -16,7 +16,7 @@
       Zurück zur Live-Ansicht
     </a>
     <button type="button" class="btn btn-secondary"
-            onclick="openRawLogModal('{{ url_for('logs_history_raw', file=selected_name) if selected_name else '' }}', 'Komplettes Log (RAW) — {{ selected_name or '' }}')"
+            onclick="openRawLogModal('{{ url_for('logs_history_raw', file=selected_name) if selected_name else '' }}', 'Komplettes Log (RAW) — {{ selected_file.range_label if selected_file else '' }}')"
             {% if not selected_name %}disabled{% endif %}>
       <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"/><path d="M14 2v6h6"/></svg>
       Komplettes Log (RAW)
@@ -26,18 +26,16 @@
 
 {% if not files %}
 <p class="text-faint" style="font-size:12.5px;">
-  Noch keine rotierten Live-Logs vorhanden — sobald logrotate das aktuelle
-  <a href="{{ url_for('logs') }}" style="color:var(--accent-strong); font-weight:600;">Live-Log</a>
-  zum ersten Mal rotiert (siehe Rotations-Intervall unter Systemeinstellungen), erscheinen ältere Stände hier.
+  Kein Live-Log gefunden.
 </p>
 {% else %}
 
 <div class="flex gap-2" style="align-items:center; margin-bottom:14px;">
-  <label for="history-file-select" class="text-faint" style="font-size:12.5px; font-weight:600;">Archiv-Stand:</label>
-  <select id="history-file-select" onchange="window.location.href=this.value;" class="mono" style="max-width:420px;">
+  <label for="history-file-select" class="text-faint" style="font-size:12.5px; font-weight:600;">Zeitraum:</label>
+  <select id="history-file-select" onchange="window.location.href=this.value;" class="mono" style="max-width:460px;">
     {% for f in files %}
     <option value="{{ url_for('logs_history', file=f.filename) }}" {% if f.filename == selected_name %}selected{% endif %}>
-      {{ f.filename }} — rotiert am {{ f.mtime_str }} ({{ f.size_str }})
+      {% if f.generation == 0 %}Aktuell — {{ f.range_label }}{% else %}{{ f.range_label }}{% endif %} ({{ f.size_str }})
     </option>
     {% endfor %}
   </select>
@@ -46,39 +44,19 @@
 <div class="log-shell">
   <div class="log-toolbar">
     <div class="log-dots"><span></span><span></span><span></span></div>
-    <span class="text-faint mono" style="font-size:11.5px;">{{ selected_name }}</span>
-    <span class="text-faint mono" style="font-size:11.5px;">{% if total_lines %}letzte {{ tail_lines }} von {{ total_lines }} Zeilen{% endif %}</span>
+    <span class="text-faint mono" style="font-size:11.5px;">{{ selected_file.range_label if selected_file else "" }}</span>
+    <span class="text-faint mono" style="font-size:11.5px;">{% if total_lines %}letzte {{ tail_lines }} von {{ total_lines }} Zeilen — RAW{% endif %}</span>
   </div>
-  <div id="log-box">{{ log_content or "" }}</div>
+  <pre id="log-box" class="raw-log-content" style="height:100%;">{{ log_content or "" }}</pre>
 </div>
 {% endif %}
 {% endblock %}
 
 {% block scripts %}
 <script>
-function colorizeLine(line) {
-    let cls = "";
-    if (line.includes(" ist erreichbar!")) cls = "online";
-    else if (line.includes(" ist nicht erreichbar!")) cls = "offline";
-    else if (line.startsWith("----")) cls = "sep";
-    else if (line.toLowerCase().includes("manuell") || line.includes("PoE")) cls = "restart";
-    const span = document.createElement("span");
-    span.className = "log-line" + (cls ? " " + cls : "");
-    span.textContent = line;
-    return span;
-}
-
 document.addEventListener("DOMContentLoaded", () => {
     const box = document.getElementById("log-box");
-    if (!box) return;
-    const text = box.textContent;
-    box.innerHTML = "";
-    const lines = text.split("\n");
-    lines.forEach((line, i) => {
-        box.appendChild(colorizeLine(line));
-        if (i < lines.length - 1) box.appendChild(document.createElement("br"));
-    });
-    box.scrollTop = box.scrollHeight;
+    if (box) box.scrollTop = box.scrollHeight;
 });
 </script>
 {% endblock %}

srv/tesm/templates/settings_nginx.html

@@ -0,0 +1,206 @@
+{% extends "base.html" %}
+{% set active_page = "settings_nginx" %}
+{% set can_edit = current_user.has_permission('settings_nginx.edit') %}
+{% block page_title %}NGINX{% endblock %}
+{% block page_sub %}<div class="topbar-sub">Reverse-Proxy: Domain, Ports, SSL/HSTS und Zertifikat</div>{% endblock %}
+
+{% block content %}
+<div class="settings-grid" style="grid-template-columns: repeat(auto-fit, minmax(420px, 1fr));">
+
+  <div class="card card-pad">
+    <div class="section-head" style="margin-bottom:16px;">
+      <div>
+        <h2 style="font-size:16px;">Reverse-Proxy</h2>
+        <div class="hint">Domain (server_name), Ports und HTTPS/HSTS für den nginx-Reverse-Proxy vor der App.</div>
+      </div>
+      <button type="button" class="btn btn-secondary btn-sm"
+              onclick="openRawLogModal('{{ url_for('settings_nginx_raw') }}', 'Aktuelle nginx-Konfiguration (RAW)')">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"/><path d="M14 2v6h6"/></svg>
+        RAW-Konfiguration
+      </button>
+    </div>
+
+    {% if pending_nginx_token %}
+    <div class="card-pad" style="background:var(--warning-dim); border-radius:var(--radius-sm); margin-bottom:16px;">
+      <p style="margin:0 0 12px; font-size:13px;">
+        Neue nginx-Konfiguration wurde angewendet. Wenn diese Seite gerade noch lädt, funktioniert die Verbindung —
+        bitte bestätigen, bevor automatisch zurückgerollt wird (nach {{ nginx_revert_seconds }}s ohne Bestätigung).
+      </p>
+      <form method="post">
+        <input type="hidden" name="confirm_nginx" value="{{ pending_nginx_token }}">
+        <button type="submit" class="btn btn-primary">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6L9 17l-5-5"/></svg>
+          Verbindung funktioniert — bestätigen
+        </button>
+      </form>
+    </div>
+    {% elif can_edit %}
+    <form method="post"
+          data-confirm="nginx-Konfiguration wirklich ändern? Falls die Verbindung danach abbricht, wird die vorherige Konfiguration automatisch nach {{ nginx_revert_seconds }} Sekunden wiederhergestellt.">
+      <div class="field">
+        <label for="server_name">Domain (server_name)</label>
+        <input type="text" name="server_name" id="server_name" value="{{ server_name }}" placeholder="_ (kein bestimmter Hostname) oder z.B. tesm.example.com">
+        <div class="field-hint">"_" ist nginx' Catch-all (Standard für interne Instanzen ohne eigene Domain) — für Let's Encrypt muss hier die tatsächliche, öffentlich auflösbare Domain stehen.</div>
+      </div>
+      <div class="flex gap-2">
+        <div class="field" style="flex:1;">
+          <label for="http_port">HTTP-Port</label>
+          <input type="number" name="http_port" id="http_port" min="1" max="65535" value="{{ http_port }}" required>
+        </div>
+        <div class="field" style="flex:1;">
+          <label for="https_port">HTTPS-Port</label>
+          <input type="number" name="https_port" id="https_port" min="1" max="65535" value="{{ https_port }}" required>
+        </div>
+      </div>
+      <div class="field-hint" style="margin-top:-8px; margin-bottom:14px;">
+        Let's Encrypt validiert IMMER über Port 80 (protokollbedingt, unabhängig vom hier eingestellten HTTP-Port) —
+        weicht der HTTP-Port von 80 ab, wird dafür automatisch zusätzlich ein minimaler Port-80-Block mitgeschrieben.
+      </div>
+      <div class="field">
+        <label class="switch-check" style="display:inline-flex; align-items:center; gap:8px;">
+          <input type="checkbox" name="ssl_enabled" id="ssl_enabled_check" {% if ssl_enabled %}checked{% endif %} {% if not cert_info %}disabled{% endif %}>
+          <span class="track"></span>
+          <span>SSL/HTTPS aktivieren</span>
+        </label>
+        {% if not cert_info %}<div class="field-hint">Erst nach Hochladen oder Anfordern eines Zertifikats verfügbar.</div>{% endif %}
+      </div>
+      <div class="field">
+        <label class="switch-check" style="display:inline-flex; align-items:center; gap:8px;">
+          <input type="checkbox" name="hsts_enabled" id="hsts_enabled_check" {% if hsts_enabled %}checked{% endif %} {% if not ssl_enabled %}disabled{% endif %}>
+          <span class="track"></span>
+          <span>HSTS (Strict-Transport-Security)</span>
+        </label>
+        <div class="field-hint">Weist Browser an, diese Instanz künftig NUR noch über HTTPS aufzurufen — bleibt auch bei einem späteren Zurückschalten auf HTTP im Browser für 1 Jahr bestehen. Nur aktivieren, wenn das Zertifikat dauerhaft gepflegt wird.</div>
+      </div>
+      <button type="submit" name="apply_nginx" value="1" class="btn btn-primary btn-block">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M9 12l2 2 4-4"/><path d="M12 2l8 4v6c0 5-3.5 8.5-8 10-4.5-1.5-8-5-8-10V6z"/></svg>
+        Anwenden
+      </button>
+    </form>
+    {% else %}
+    <p class="text-faint" style="font-size:12.5px;">Für Änderungen fehlt das Recht „NGINX ändern“.</p>
+    {% endif %}
+  </div>
+
+  <div class="card card-pad">
+    <div class="section-head" style="margin-bottom:16px;">
+      <div>
+        <h2 style="font-size:16px;">Zertifikat</h2>
+        <div class="hint">Hochladen (PEM) oder automatisch per Let's Encrypt anfordern — mit automatischer Verlängerung über certbots eigenen Timer.</div>
+      </div>
+    </div>
+
+    {% if cert_info %}
+    <div class="detail-list" style="margin-bottom:18px;">
+      <div class="detail-row"><span class="k">Quelle</span><span class="v">{{ "Let's Encrypt" if cert_info.source == "letsencrypt" else "Hochgeladen" }}</span></div>
+      <div class="detail-row"><span class="k">Subject</span><span class="v" style="text-align:right; word-break:break-all;">{{ cert_info.subject }}</span></div>
+      <div class="detail-row"><span class="k">Aussteller</span><span class="v" style="text-align:right; word-break:break-all;">{{ cert_info.issuer }}</span></div>
+      <div class="detail-row">
+        <span class="k">Gültig bis</span>
+        <span class="v">
+          {{ cert_info.not_after.strftime('%d.%m.%Y') }}
+          {% if cert_info.days_left < 0 %}
+          <span class="pill offline" style="margin-left:6px;">abgelaufen</span>
+          {% elif cert_info.days_left <= 30 %}
+          <span class="pill unknown" style="margin-left:6px;">noch {{ cert_info.days_left }} Tage</span>
+          {% else %}
+          <span class="pill online" style="margin-left:6px;">noch {{ cert_info.days_left }} Tage</span>
+          {% endif %}
+        </span>
+      </div>
+      {% if cert_info.source == "letsencrypt" %}
+      <div class="detail-row">
+        <span class="k">Automatische Verlängerung</span>
+        <span class="v">
+          {% if certbot_timer and certbot_timer.active %}
+          <span class="pill online">aktiv</span>
+          {% if certbot_timer.next_run %}<span class="text-faint" style="font-size:11px; display:block; margin-top:2px;">nächster Lauf: {{ certbot_timer.next_run }}</span>{% endif %}
+          {% elif certbot_timer %}
+          <span class="pill offline">inaktiv</span>
+          {% else %}
+          <span class="pill unknown">unbekannt</span>
+          {% endif %}
+        </span>
+      </div>
+      {% endif %}
+    </div>
+    {% if cert_info.source == "letsencrypt" and can_edit %}
+    <div class="flex gap-2" style="margin-bottom:18px;">
+      <form method="post" style="flex:1;">
+        <button type="submit" name="test_renewal" value="1" class="btn btn-secondary btn-block btn-sm">Verlängerung testen (Dry-Run)</button>
+      </form>
+      <form method="post" style="flex:1;" data-confirm="Zertifikat jetzt sofort erneuern (zählt gegen Let's Encrypts Rate-Limits)?">
+        <button type="submit" name="force_renew" value="1" class="btn btn-secondary btn-block btn-sm">Jetzt manuell verlängern</button>
+      </form>
+    </div>
+    {% endif %}
+    {% else %}
+    <p class="text-faint" style="font-size:12.5px; margin-bottom:18px;">Noch kein Zertifikat hinterlegt.</p>
+    {% endif %}
+
+    {% if can_edit %}
+    <div class="field">
+      <label style="font-weight:600; font-size:13px;">Let's Encrypt anfordern</label>
+      <div class="field-hint" style="margin-bottom:8px;">Setzt voraus, dass die Domain öffentlich auf diesen Host auflöst und Port 80 aus dem Internet erreichbar ist (HTTP-01-Validierung) — für rein interne Instanzen ohne öffentliche Domain nicht nutzbar, dann stattdessen hochladen. Verlängerung läuft danach automatisch über certbots eigenen Timer{% if certbot_timer %} ({{ "aktiv" if certbot_timer.active else "inaktiv!" }}){% endif %}, zweimal täglich.</div>
+    </div>
+    <form method="post" style="margin-bottom:18px;">
+      <div class="field">
+        <label for="le_domain">Domain</label>
+        <input type="text" name="le_domain" id="le_domain" placeholder="z.B. tesm.example.com" value="{{ server_name if server_name != '_' else '' }}">
+      </div>
+      <div class="field">
+        <label for="le_email">E-Mail (optional, für Ablauf-Erinnerungen)</label>
+        <input type="email" name="le_email" id="le_email" placeholder="admin@example.com">
+      </div>
+      <button type="submit" name="request_letsencrypt" value="1" class="btn btn-secondary btn-block">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2l8 4v6c0 5-3.5 8.5-8 10-4.5-1.5-8-5-8-10V6z"/><path d="M9 12l2 2 4-4"/></svg>
+        Zertifikat anfordern
+      </button>
+    </form>
+
+    <div class="field"><label style="font-weight:600; font-size:13px;">Manuell hochladen</label></div>
+    <form method="post" enctype="multipart/form-data" style="margin-bottom:10px;">
+      <div class="field">
+        <label for="cert_file">Zertifikat (PEM, .crt/.pem)</label>
+        <input type="file" name="cert_file" id="cert_file" accept=".pem,.crt,.cer" required>
+      </div>
+      <div class="field">
+        <label for="key_file">Privater Schlüssel (PEM, unverschlüsselt)</label>
+        <input type="file" name="key_file" id="key_file" accept=".pem,.key" required>
+        <div class="field-hint">Ein passwortgeschütztes Schlüssel wird abgelehnt — nginx könnte ihn beim Start ohnehin nicht ohne manuelle Passworteingabe laden.</div>
+      </div>
+      <button type="submit" name="upload_cert" value="1" class="btn btn-secondary btn-block">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><path d="M17 8l-5-5-5 5"/><path d="M12 3v12"/></svg>
+        Zertifikat + Schlüssel hochladen
+      </button>
+    </form>
+
+    {% if cert_info and not ssl_enabled %}
+    <form method="post" data-confirm="Hinterlegtes Zertifikat wirklich entfernen?" data-no-unsaved-guard>
+      <button type="submit" name="remove_cert" value="1" class="btn btn-danger btn-block">Zertifikat entfernen</button>
+    </form>
+    {% elif cert_info %}
+    <p class="text-faint" style="font-size:11.5px;">SSL muss zuerst deaktiviert werden, bevor das Zertifikat entfernt werden kann.</p>
+    {% endif %}
+    {% else %}
+    <p class="text-faint" style="font-size:12.5px;">Für Anfordern/Upload/Entfernen fehlt das Recht „NGINX ändern“.</p>
+    {% endif %}
+  </div>
+
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+document.addEventListener("DOMContentLoaded", () => {
+    const sslCheck = document.getElementById("ssl_enabled_check");
+    const hstsCheck = document.getElementById("hsts_enabled_check");
+    if (sslCheck && hstsCheck) {
+        sslCheck.addEventListener("change", () => {
+            hstsCheck.disabled = !sslCheck.checked;
+            if (!sslCheck.checked) hstsCheck.checked = false;
+        });
+    }
+});
+</script>
+{% endblock %}

update.sh

@@ -9,16 +9,15 @@
 # automatischem Backup + Migrations-Sicherheitsnetz samt Rückroll-
 # Möglichkeit -- siehe install.sh für Details).
 #
-# Dieses Skript selbst ist nur noch für das Ablösen ÄLTERER, TESM
-# vorausgehender Installationsstufen auf diesem Host zuständig:
-#   1. Das ursprüngliche, reine Bash-Setup aus dem separaten Repo
-#      https://gitea.int.eertmoed.net/WiS/Aruba-PoE (rpi-check.service +
-#      statische ips.list, keine Datenbank/Web-UI).
-#   2. Die spätere Flask-App "PoE Manager" unter /srv/poe_manager
-#      (poe_web.service, Vorgänger von TESM in diesem Repo vor der
-#      Umbenennung).
-# Beide werden NICHT gelöscht, sondern nur gestoppt/deaktiviert und
-# (falls vorhanden) beiseite verschoben.
+# Dieses Skript ist reiner Bootstrapper: Download + Entpacken + Aufruf von
+# install.sh. Die frühere Sonderbehandlung zweier TESM vorausgehender
+# Installationsstufen (rpi-check.service aus dem ursprünglichen reinen
+# Bash-Setup, poe_web.service/poe_manager als Flask-Vorgänger von TESM)
+# wurde entfernt -- diese Stufen sind auf allen aktuellen Installationen
+# längst migriert, die dazugehörigen Unit-Dateien wurden dort manuell
+# entfernt. Ein heute noch unmigriertes System wäre ohnehin so alt, dass
+# ein manueller Blick vor dem Update angebracht ist statt automatischer
+# stillschweigender Bereinigung.
 #
 # Auszuführen als root auf dem Zielsystem:
 #   sudo ./update.sh
@@ -38,7 +37,6 @@ GITEA_TOKEN="${TESM_GITEA_TOKEN:-}"
 PACKAGE_NAME="tesm-${RELEASE_TAG}.tar.gz"
 DOWNLOAD_URL="${GITEA_BASE}/${REPO_OWNER}/${REPO_NAME}/releases/download/${RELEASE_TAG}/${PACKAGE_NAME}"
 
-TIMESTAMP="$(date +%Y%m%d-%H%M%S)"
 WORK_DIR="/tmp/tesm-update-$(date +%s)"
 PACKAGE_FILE="$WORK_DIR/${PACKAGE_NAME}"
 
@@ -61,10 +59,6 @@ echo "install.sh daraus -- das erkennt selbst, ob es sich um eine frische"
 echo "Installation oder ein Update einer bestehenden handelt, und sichert"
 echo "die Datenbank bei einer Schema-Änderung automatisch vorsorglich ab."
 echo
-echo "Ältere, TESM vorausgehende Installationsstufen (PoE Manager unter"
-echo "/srv/poe_manager, das ursprüngliche reine Bash-Setup) werden dabei"
-echo "erkannt, gestoppt/deaktiviert und beiseite verschoben (nicht gelöscht)."
-echo
 
 read -r -p "Fortfahren? [y/N] " confirm
 if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
@@ -86,22 +80,6 @@ mkdir -p "$WORK_DIR/pkg"
 tar xzf "$PACKAGE_FILE" -C "$WORK_DIR/pkg" --strip-components=1
 echo -e "${GREEN}✔${NC} Paket entpackt."
 
-echo -e "${RED}→${NC} Stoppe/deaktiviere ältere Installationsstufen (falls vorhanden)..."
-# "|| true" macht nichts kaputt, falls einzelne Units gar nicht vorhanden
-# sind. tesm.service selbst wird NICHT hier, sondern von install.sh
-# gestoppt -- das entscheidet dort auch gleich, ob ein Backup nötig ist.
-systemctl stop poe_web.service 2>/dev/null || true
-systemctl disable poe_web.service 2>/dev/null || true
-systemctl stop rpi-check.service rpi-check-restart.service rpi-check-restart.timer 2>/dev/null || true
-systemctl disable rpi-check.service rpi-check-restart.service rpi-check-restart.timer 2>/dev/null || true
-if [ -d /srv/poe_manager ]; then
-    dest="/srv/poe_manager-backup-${TIMESTAMP}"
-    echo -e "${RED}→${NC} Sichere /srv/poe_manager nach ${dest}..."
-    mv /srv/poe_manager "$dest"
-    echo -e "${GREEN}✔${NC} Gesichert (nicht gelöscht)."
-fi
-echo -e "${GREEN}✔${NC} Ältere Installationsstufen bereinigt."
-
 echo -e "${RED}→${NC} Starte install.sh aus dem Paket..."
 bash "$WORK_DIR/pkg/install.sh"