158 lines
8.6 KiB
Python
158 lines
8.6 KiB
Python
"""
|
|
Zentrale Konfiguration der Jumphost-Anwendung.
|
|
|
|
Secrets (KEK, Session-Signaturschluessel) werden bevorzugt ueber systemd
|
|
Credentials geladen (siehe systemd LoadCredentialEncrypted= im Unit-File,
|
|
$CREDENTIALS_DIRECTORY zur Laufzeit). Fuer lokale Entwicklung/Tests wird auf
|
|
Umgebungsvariablen bzw. eine lokale .env-Datei zurueckgefallen -- das ist
|
|
NICHT fuer den Produktivbetrieb gedacht.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import secrets
|
|
from dataclasses import dataclass, field
|
|
from pathlib import Path
|
|
|
|
|
|
def _read_credential(name: str, env_fallback: str | None = None, *, required: bool = True) -> bytes | None:
|
|
"""Liest ein Secret aus $CREDENTIALS_DIRECTORY (systemd-creds) oder Fallback-Env.
|
|
|
|
Der Wert wird als Hex-String erwartet (z.B. per `openssl rand -hex 32`
|
|
erzeugt) und hier zu den zugrundeliegenden Rohbytes dekodiert -- passend
|
|
zum selben Format, das auch fuer JUMPHOST_DEV_KEK/JUMPHOST_DEV_SESSION_SECRET
|
|
im development-Zweig unten verwendet wird (s. Konzept 6.4). Vorher wurde
|
|
dieser Wert hier NICHT dekodiert, sondern roh als Bytes interpretiert --
|
|
das fuehrte bei einem korrekt per `openssl rand -hex 32` erzeugten
|
|
64-Zeichen-Hex-String (= 32 Byte Entropie) zu einer 64-Byte-Rohlaenge und
|
|
damit zum Fehler "KEK muss genau 32 Bytes lang sein".
|
|
"""
|
|
cred_dir = os.environ.get("CREDENTIALS_DIRECTORY")
|
|
raw: bytes | None = None
|
|
if cred_dir:
|
|
cred_path = Path(cred_dir) / name
|
|
if cred_path.exists():
|
|
raw = cred_path.read_bytes().strip()
|
|
if raw is None and env_fallback and env_fallback in os.environ:
|
|
raw = os.environ[env_fallback].strip().encode()
|
|
if raw is None:
|
|
if required:
|
|
raise RuntimeError(
|
|
f"Secret '{name}' weder ueber systemd-creds noch ueber Env-Variable "
|
|
f"'{env_fallback}' verfuegbar. In Produktion MUSS dies ueber "
|
|
f"systemd LoadCredentialEncrypted= bereitgestellt werden."
|
|
)
|
|
return None
|
|
try:
|
|
return bytes.fromhex(raw.decode("ascii"))
|
|
except (ValueError, UnicodeDecodeError) as exc:
|
|
raise RuntimeError(
|
|
f"Secret '{name}' ist kein gueltiger Hex-String (erwartet z.B. das "
|
|
f"Ergebnis von `openssl rand -hex 32`)."
|
|
) from exc
|
|
|
|
|
|
@dataclass
|
|
class Settings:
|
|
app_env: str = os.environ.get("JUMPHOST_ENV", "development")
|
|
data_dir: Path = Path(os.environ.get("JUMPHOST_DATA_DIR", "/var/lib/jumphost"))
|
|
db_path: Path = field(init=False)
|
|
recordings_dir: Path = field(init=False)
|
|
|
|
# Key-Encryption-Key fuer AES-256-GCM (verschluesselt SSH-Keys/TOTP-Secrets in der DB)
|
|
kek: bytes = field(init=False)
|
|
# separater Schluessel fuer Session-Cookie-Signatur (Schluesseltrennung, siehe Konzept 6.2)
|
|
session_secret: bytes = field(init=False)
|
|
|
|
listen_uds: str = os.environ.get("JUMPHOST_LISTEN_UDS", "/run/jumphost/app.sock")
|
|
guacd_host: str = os.environ.get("JUMPHOST_GUACD_HOST", "127.0.0.1")
|
|
guacd_port: int = int(os.environ.get("JUMPHOST_GUACD_PORT", "4822"))
|
|
# Befund A3 (Umsetzungsauftrag_Sonnet5.md Teil A.3): weder der
|
|
# TCP-Verbindungsaufbau zu guacd noch die beiden read_instruction()-
|
|
# Aufrufe im guac-Handshake (args/ready) hatten ein Timeout -- antwortet
|
|
# guacd nach dem TCP-Accept nicht mehr, haengt die Coroutine unbegrenzt
|
|
# (offene sessions-Zeile ohne ended_at, offene Aufzeichnungsdatei,
|
|
# belegtes WebSocket). Je Phase konfigurierbar statt eines Werts fuer
|
|
# beides, da ein TCP-Connect-Timeout und ein Protokoll-Handshake-Timeout
|
|
# unterschiedliche Fehlerbilder abdecken (guacd-Prozess tot vs. guacd
|
|
# haengt mitten im Protokoll).
|
|
guacd_connect_timeout_s: float = float(os.environ.get("JUMPHOST_GUACD_CONNECT_TIMEOUT", "10"))
|
|
guacd_handshake_timeout_s: float = float(os.environ.get("JUMPHOST_GUACD_HANDSHAKE_TIMEOUT", "10"))
|
|
|
|
session_idle_timeout_s: int = int(os.environ.get("JUMPHOST_SESSION_IDLE_TIMEOUT", "900"))
|
|
session_absolute_timeout_s: int = int(os.environ.get("JUMPHOST_SESSION_ABS_TIMEOUT", "28800"))
|
|
max_failed_logins: int = int(os.environ.get("JUMPHOST_MAX_FAILED_LOGINS", "5"))
|
|
lockout_base_seconds: int = int(os.environ.get("JUMPHOST_LOCKOUT_BASE_SECONDS", "30"))
|
|
|
|
# Sitzungsaufzeichnung (Umsetzungsauftrag Teil A/D2, Teil E/E2): Puffer-
|
|
# Zeitfenster, Groesse je Teildatei (Rotation) und Gesamtgroesse je
|
|
# Sitzung (harte Obergrenze -- Aufzeichnung wird danach mit einem
|
|
# Abschluss-Eintrag abgeschnitten, die Sitzung selbst laeuft normal
|
|
# weiter). Siehe app/recordings/recorder.py.
|
|
recording_flush_interval_s: float = float(os.environ.get("JUMPHOST_RECORDING_FLUSH_INTERVAL_S", "1.0"))
|
|
recording_max_part_bytes: int = int(os.environ.get("JUMPHOST_RECORDING_MAX_PART_BYTES", str(50 * 1024 * 1024)))
|
|
recording_max_total_bytes: int = int(os.environ.get("JUMPHOST_RECORDING_MAX_TOTAL_BYTES", str(500 * 1024 * 1024)))
|
|
|
|
# Dateitransfer (Umsetzungsauftrag Teil E, E4): Obergrenze gleichzeitig
|
|
# laufender Uploads+Downloads ueber alle Benutzer hinweg. Ohne Grenze
|
|
# koennten mehrere parallele 200-MiB-Transfers den Prozess in den
|
|
# OOM-Killer treiben (siehe app/ssh_proxy/sftp.py).
|
|
max_concurrent_transfers: int = int(os.environ.get("JUMPHOST_MAX_CONCURRENT_TRANSFERS", "8"))
|
|
|
|
# SSH-Terminal-Sitzungen (Umsetzungsauftrag Teil E):
|
|
# E10 -- Inaktivitaet wird in BEIDEN Richtungen gemessen (Eingaben UND
|
|
# Ausgaben vom Ziel, z.B. ein laufendes `tail -f`), nicht mehr nur an
|
|
# websocket.receive_json() (Benutzereingaben). Vorher wurde eine
|
|
# inhaltlich aktive, aber eingabelose Sitzung nach 15 Minuten getrennt.
|
|
ssh_idle_timeout_s: int = int(os.environ.get("JUMPHOST_SSH_IDLE_TIMEOUT", "900"))
|
|
# E11 -- vorher als MAX_SESSION_SECONDS-Konstante in
|
|
# app/ssh_proxy/terminal_ws.py definiert, aber nirgends verwendet: es gab
|
|
# de facto GAR KEINE absolute Obergrenze fuer eine SSH-Sitzung, anders
|
|
# als beim Anmelde-Cookie (session_absolute_timeout_s oben). Jetzt aktiv
|
|
# durchgesetzt, mit Vorwarnung (siehe ssh_max_session_warning_s).
|
|
ssh_max_session_seconds: int = int(os.environ.get("JUMPHOST_SSH_MAX_SESSION_SECONDS", str(8 * 3600)))
|
|
ssh_max_session_warning_s: int = int(os.environ.get("JUMPHOST_SSH_MAX_SESSION_WARNING_S", "60"))
|
|
|
|
# E8 (Umsetzungsauftrag Teil E): IP-basiertes Login-Rate-Limit. Bewusst
|
|
# NICHT automatisch an eine erkannte Benutzerzahl angepasst -- ob mehrere
|
|
# interne Benutzer hinter derselben NAT-Adresse sitzen (typischer
|
|
# Buero-Fall) ist eine Betriebsentscheidung, die zusammen mit dem
|
|
# nginx-limit_req (ansible/roles/nginx_proxy) und der fail2ban-Schwelle
|
|
# (ansible/roles/fail2ban) getroffen werden muss -- siehe deren
|
|
# jumphost_login_rate_limit_* group_vars. Der kontenbezogene Lockout
|
|
# (max_failed_logins oben) bleibt in jedem Fall die scharfe, IP-
|
|
# unabhaengige Bremse.
|
|
login_rate_limit_max_events: int = int(os.environ.get("JUMPHOST_LOGIN_RATE_LIMIT_MAX_EVENTS", "10"))
|
|
login_rate_limit_window_s: int = int(os.environ.get("JUMPHOST_LOGIN_RATE_LIMIT_WINDOW_S", "60"))
|
|
|
|
# E.4 (Umsetzungsauftrag Teil E): Obergrenzen fuer gleichzeitige SSH/RDP-
|
|
# Sitzungen. Vorher gab es WEDER einen Zaehler je Benutzer NOCH einen
|
|
# globalen Zaehler -- mit der Mehrsitzungs-Seitenleiste (Teil F) wird es
|
|
# zur Normalitaet, dass ein Benutzer mehrere Sitzungen gleichzeitig haelt,
|
|
# jede kostet mindestens einen zusaetzlichen Socket zum Ziel (RDP
|
|
# zusaetzlich die guacd-Verbindung) plus eine Aufzeichnungsdatei.
|
|
max_sessions_per_user: int = int(os.environ.get("JUMPHOST_MAX_SESSIONS_PER_USER", "6"))
|
|
max_sessions_global: int = int(os.environ.get("JUMPHOST_MAX_SESSIONS_GLOBAL", "100"))
|
|
|
|
def __post_init__(self) -> None:
|
|
self.db_path = self.data_dir / "jumphost.db"
|
|
self.recordings_dir = self.data_dir / "recordings"
|
|
|
|
if self.app_env == "development":
|
|
# Nur fuer lokale Entwicklung: deterministisch aus Env oder Zufallswert je Prozessstart.
|
|
kek_hex = os.environ.get("JUMPHOST_DEV_KEK")
|
|
self.kek = bytes.fromhex(kek_hex) if kek_hex else secrets.token_bytes(32)
|
|
sess_hex = os.environ.get("JUMPHOST_DEV_SESSION_SECRET")
|
|
self.session_secret = bytes.fromhex(sess_hex) if sess_hex else secrets.token_bytes(32)
|
|
else:
|
|
self.kek = _read_credential("jumphost_kek", "JUMPHOST_KEK")
|
|
self.session_secret = _read_credential("jumphost_session_secret", "JUMPHOST_SESSION_SECRET")
|
|
|
|
if len(self.kek) != 32:
|
|
raise RuntimeError("KEK muss genau 32 Bytes (256 Bit) lang sein.")
|
|
if len(self.session_secret) != 32:
|
|
raise RuntimeError("Session-Secret muss genau 32 Bytes (256 Bit) lang sein.")
|
|
|
|
|
|
settings = Settings()
|