From 23312854fc4ae1742554e28f1db3cf82fd483684 Mon Sep 17 00:00:00 2001 From: Madzone Date: Wed, 9 Sep 2026 13:31:53 +0200 Subject: [PATCH] New Version --- PVE-IDM/CHANGELOG.md | 15 ++++ PVE-IDM/README.md | 101 +++++++++++++++++++++++++- PVE-IDM/VERSION | 2 +- PVE-IDM/group_vars/all.yml.example | 4 + PVE-IDM/playbook/logout-remove.yml | 10 +++ PVE-IDM/playbook/logout.yml | 19 +++++ PVE-IDM/playbook/site.yml | 1 + PVE-IDM/scripts/logout_patch.py | 113 +++++++++++++++++++++++++++++ PVE-IDM/setup.py | 45 +++++++++++- PVE-IDM/tasks/keycloak.yml | 8 ++ PVE-IDM/tasks/logout.yml | 60 +++++++++++++++ PVE-IDM/tests/test_logout.py | 101 ++++++++++++++++++++++++++ PVE-IDM/tests/test_setup.py | 23 ++++++ 13 files changed, 498 insertions(+), 4 deletions(-) create mode 100644 PVE-IDM/playbook/logout-remove.yml create mode 100644 PVE-IDM/playbook/logout.yml create mode 100644 PVE-IDM/scripts/logout_patch.py create mode 100644 PVE-IDM/tasks/logout.yml create mode 100644 PVE-IDM/tests/test_logout.py diff --git a/PVE-IDM/CHANGELOG.md b/PVE-IDM/CHANGELOG.md index 1674092..a5a7e8c 100644 --- a/PVE-IDM/CHANGELOG.md +++ b/PVE-IDM/CHANGELOG.md @@ -1,5 +1,20 @@ # Änderungsprotokoll +## [1.2.1] – 2026-09-09 + +- Rückbau direkt über `setup.py --rollback-logout` mit Inventory-/SSH-/sudo-Abfragen. +- Nach erfolgreichem Rückbau automatische lokale Deaktivierung des Logout-Patches. +- Manueller Rückbau ohne Ansible in der README ergänzt. + +## [1.2.0] – 2026-09-09 + +- Optionaler Desktop-Logout-Patch: lokale PVE-Abmeldung mit anschließender + Keycloak-Weiterleitung ausschließlich für den konfigurierten OIDC-Realm. +- TLS-geprüfte Endpoint-Discovery und Keycloak-Post-Logout-Redirect-Konfiguration. +- Versions-/Strukturprüfung, SHA-256-Sicherungen, idempotenter Lauf und Rückbau. +- Logout-Abfrage im Assistenten sowie separate Installations-/Rückbau-Playbooks. +- Lokale Tests für Patch-Lebenszyklus, Paketupdates und Schutz vor Überschreiben. + ## [1.1.0] – 2026-09-08 - Interaktiver Einrichtungsassistent `setup.py` für Host/IP, SSH, OIDC, CA/Java, diff --git a/PVE-IDM/README.md b/PVE-IDM/README.md index 8f46073..60c05b2 100644 --- a/PVE-IDM/README.md +++ b/PVE-IDM/README.md @@ -1,6 +1,6 @@ # PVE 9 + Keycloak OIDC für HEIMLAN -Version: **1.1.0** · [Änderungsprotokoll](CHANGELOG.md) · [Versionsdatei](VERSION) +Version: **1.2.1** · [Änderungsprotokoll](CHANGELOG.md) · [Versionsdatei](VERSION) Dieses Ansible-Setup konfiguriert den bestehenden PVE-Host **ts01** und eine bestehende **Keycloak-VM**. Es installiert die private Root-CA auf beiden Betriebssystemen sowie im Java- und Keycloak-Truststore, richtet Realm, Client, Gruppen, Mapper und Sessions ein und ergänzt PVE-ACLs ausschließlich für bereits vorhandene Gruppen. Alle Module gehören zu `ansible.builtin`. @@ -161,7 +161,7 @@ Secret-Rotation: `ansible-vault edit group_vars/vault.yml`, denselben neuen Clie Die Realm-SSO-Werte betreffen alle Anwendungen dieses Keycloak-Realms. Client-Overrides können die globale SSO-Grenze nicht verlängern. Kürzere Client-Sessions erzwingen bei weiterhin aktiver SSO-Session nicht zwangsläufig eine neue Passworteingabe. -Keycloak-Sessionablauf ist außerdem keine PVE-Ticket-Laufzeit: PVE-Aktivität muss Keycloak nicht aktiv halten und ein abgelaufener Keycloak-Login beendet nicht automatisch ein bereits ausgestelltes PVE-Ticket. Das Paket implementiert keinen Single-Logout-Patch; lokales PVE-Logout beendet die Keycloak-SSO-Session nicht automatisch. +Keycloak-Sessionablauf ist außerdem keine PVE-Ticket-Laufzeit: PVE-Aktivität muss Keycloak nicht aktiv halten und ein abgelaufener Keycloak-Login beendet nicht automatisch ein bereits ausgestelltes PVE-Ticket. Ohne aktivierten optionalen Logout-Patch beendet lokales PVE-Logout die Keycloak-SSO-Session nicht automatisch. ## Prüfung und Fehlerdiagnose @@ -190,3 +190,100 @@ Das Paket wird lokal auf YAML-/Ansible-Syntax und ausgewählte Entscheidungslogi - [Keycloak Truststore](https://www.keycloak.org/server/keycloak-truststore) - [Keycloak Session-Verwaltung](https://www.keycloak.org/docs/latest/server_admin/) - [Keycloak Client-Session-Attributnamen](https://github.com/keycloak/keycloak/blob/main/server-spi-private/src/main/java/org/keycloak/protocol/oidc/OIDCConfigAttributes.java) + +## Optional: PVE-Logout → Keycloak-Logout (ab 1.2.0) + +Im Einrichtungsassistenten die Logout-Frage mit `j` beantworten. Für eine bereits +vorhandene Konfiguration diese zwei Werte in `group_vars/all.yml` ergänzen +(bei JSON-Syntax innerhalb des vorhandenen Objekts): + +```yaml +pve_logout_enabled: true +pve_logout_redirect_uri: https://ts01.heim.lan:8006/ +``` + +Die Rücksprungadresse muss exakt in `pve_redirect_uris` enthalten sein. Dann entweder +den vollständigen Lauf verwenden oder bei bereits eingerichtetem CA-/OIDC-Setup: + +```bash +ansible-playbook -i inventory/hosts.local.yml playbook/logout.yml --ask-vault-pass +``` + +`logout.yml` gleicht zunächst die vorhandene Keycloak-Konfiguration mit den +Projektvariablen ab, einschließlich Realm-Sessions, Client, Gruppen und Mappern. +Es setzt zusätzlich das Clientattribut `post.logout.redirect.uris` auf die gewählte +Rücksprungadresse (eine eventuell vorhandene Logout-Redirect-Liste wird ersetzt). +Danach prüft PVE den Discovery-Endpunkt mit TLS-CA-Verifikation und installiert den Patch. + +Der Desktop-Logout merkt sich vor der lokalen Abmeldung den Benutzernamen. Nur beim +Suffix `@` leitet er nach der normalen lokalen Abmeldung zum verifizierten +Keycloak-Logout-Endpunkt weiter, mit `client_id` und `post_logout_redirect_uri`. +PAM-/andere Realms bleiben im normalen Ablauf. Es werden keine Client-Secrets in +JavaScript oder URLs eingebaut. Ohne `id_token_hint` kann Keycloak eine Bestätigung +anzeigen; diese muss der Benutzer abschließen. Erst dann ist auch die Keycloak-SSO- +Session beendet. Andere Anwendungen können von der beendeten SSO-Session betroffen sein. + +Der Patch gilt für den **Desktop-Logout-Button**. Er implementiert weder Backchannel- +Logout noch eine serverseitige Sperrung bereits ausgestellter PVE-Tickets, mobile +Oberflächen oder ein synchronisiertes Logout sämtlicher Browser-Tabs. + +### Sicherung, Updates und Rückbau + +- Ziel: `/usr/share/pve-manager/js/pvemanagerlib.js`, nur PVE 9 und genau ein bekannter + Logout-Codeblock. Unbekannte/minifizierte Varianten oder vorkomprimierte Sidecars + führen zum Abbruch; eine Major-Version allein gilt nicht als Kompatibilitätsnachweis. +- Originaldatei und SHA-256-Prüfsummen werden unter `/var/lib/pve-idm/logout` gesichert. + Identischer zweiter Lauf ändert nichts. Manuelle Änderungen an einem gepatchten + Bundle führen zum Abbruch, statt fremde Änderungen zu überschreiben. +- PVE-Paketupdates können den Patch ersetzen. Danach `logout.yml` erneut ausführen. + Der neue Originalstand wird separat gesichert. Es gibt keinen unbeaufsichtigten + Update-Hook. Bei geändertem Logout-Code ist eine erneute Anpassung erforderlich. +- Nach Installation/Rückbau die PVE-Seite vollständig neu laden, ggf. Browsercache + leeren. Bereits geöffnete Tabs enthalten noch die alte JavaScript-Version. +- Rückbau ohne Vault und ohne Keycloak-Zugriff: + +```bash +ansible-playbook -i inventory/hosts.local.yml playbook/logout-remove.yml +``` + +Danach `pve_logout_enabled: false` speichern, damit spätere Gesamtläufe den Patch +nicht erneut aktivieren. Alternativ entfernt ein Gesamtlauf mit `false` den Patch. +Der Rückbau stellt nur die nachweislich zugehörige Originaldatei wieder her; nach +Paketupdates wird keine ältere Datei zurückkopiert. Sicherungen und die zugelassene +Keycloak-Rücksprungadresse bleiben erhalten. + +### Abnahme auf den Zielhosts + +1. Desktop-Seite neu laden, OIDC-Benutzer anmelden, Logout drücken. +2. Prüfen: lokale PVE-Abmeldung, Keycloak-Bestätigung, danach Rückkehr zu PVE. +3. Erneut anmelden: Keycloak sollte eine neue Authentifizierung verlangen, sofern + kein vorgeschalteter Identity Provider erneut automatisch anmeldet. +4. Mit `root@pam` prüfen, dass keine Keycloak-Weiterleitung erfolgt. +5. Zweiten Ansible-Lauf und anschließend bei Bedarf Rückbau prüfen. + +Lokal getestet werden Patch/Rückbau, Idempotenz, Paketupdate-Verhalten und Ablehnung +veränderter Dateien. Ein Browser-/Integrationstest auf deinen Hosts steht aus. + + +### Rückbau über den Einrichtungsassistenten (ab 1.2.1) + +```bash +python3 setup.py --rollback-logout +``` + +Fragt Inventory, SSH-/sudo-Passwortbedarf und die Ausführung ab. Nach erfolgreichem +Rückbau speichert der Assistent `pve_logout_enabled: false` in der lokalen Konfiguration, +damit spätere Gesamtläufe den Patch nicht erneut installieren. Kein Vault-Passwort nötig. +Bei fehlgeschlagenem Rückbau bleibt die lokale Einstellung unverändert. + +Bei einer rein manuellen Installation ohne lokale Ansible-Konfiguration direkt auf PVE: + +```bash +python3 /root/pve-idm-logout-patch.py \ + --target /usr/share/pve-manager/js/pvemanagerlib.js \ + --state-dir /var/lib/pve-idm/logout \ + --enabled false +``` + +Auch dieser Rückbau ist bereits im Patch-Skript eingebaut. Anschließend die PVE-Seite +vollständig neu laden. Keycloak-Konfiguration und Sicherungsdateien bleiben erhalten. diff --git a/PVE-IDM/VERSION b/PVE-IDM/VERSION index 9084fa2..6085e94 100644 --- a/PVE-IDM/VERSION +++ b/PVE-IDM/VERSION @@ -1 +1 @@ -1.1.0 +1.2.1 diff --git a/PVE-IDM/group_vars/all.yml.example b/PVE-IDM/group_vars/all.yml.example index 2c39ba3..10a820e 100644 --- a/PVE-IDM/group_vars/all.yml.example +++ b/PVE-IDM/group_vars/all.yml.example @@ -48,3 +48,7 @@ pve_roles: - PVEUserAdmin - PVEVMAdmin - PVEVMUser + +# Optionaler PVE-Desktop-Logout-Patch (Keycloak fragt ggf. nach Bestätigung). +pve_logout_enabled: false +pve_logout_redirect_uri: "{{ pve_redirect_uris[0] }}" diff --git a/PVE-IDM/playbook/logout-remove.yml b/PVE-IDM/playbook/logout-remove.yml new file mode 100644 index 0000000..4d6d54c --- /dev/null +++ b/PVE-IDM/playbook/logout-remove.yml @@ -0,0 +1,10 @@ +- name: Remove PVE logout patch without downgrading package files + hosts: pve + become: true + gather_facts: false + vars_files: + - ../group_vars/all.yml + tasks: + - ansible.builtin.import_tasks: ../tasks/logout.yml + vars: + pve_logout_enabled: false diff --git a/PVE-IDM/playbook/logout.yml b/PVE-IDM/playbook/logout.yml new file mode 100644 index 0000000..b8a1d19 --- /dev/null +++ b/PVE-IDM/playbook/logout.yml @@ -0,0 +1,19 @@ +- name: Register logout return URI on existing Keycloak + hosts: keycloak + become: true + gather_facts: false + vars_files: + - ../group_vars/all.yml + - ../group_vars/vault.yml + tasks: + - ansible.builtin.import_tasks: ../tasks/keycloak.yml + when: pve_logout_enabled | default(false) | bool + +- name: Configure PVE desktop logout + hosts: pve + become: true + gather_facts: false + vars_files: + - ../group_vars/all.yml + tasks: + - ansible.builtin.import_tasks: ../tasks/logout.yml diff --git a/PVE-IDM/playbook/site.yml b/PVE-IDM/playbook/site.yml index b6799eb..ba53c22 100644 --- a/PVE-IDM/playbook/site.yml +++ b/PVE-IDM/playbook/site.yml @@ -33,3 +33,4 @@ tasks: - ansible.builtin.import_tasks: ../tasks/pve.yml - ansible.builtin.import_tasks: ../tasks/acl.yml + - ansible.builtin.import_tasks: ../tasks/logout.yml diff --git a/PVE-IDM/scripts/logout_patch.py b/PVE-IDM/scripts/logout_patch.py new file mode 100644 index 0000000..7f3a088 --- /dev/null +++ b/PVE-IDM/scripts/logout_patch.py @@ -0,0 +1,113 @@ +#!/usr/bin/env python3 +"""Guarded PVE 9 desktop logout patch. No credentials are used.""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import re +import tempfile +from urllib.parse import urlsplit + +MARK = '/* PVE-IDM LOGOUT v1 */' +ANCHOR = re.compile(r"(text:\s*gettext\('Logout'\),\s*handler:\s*function\s*\(\)\s*\{)(\s*PVE\.data\.ResourceStore\.loadData\(\[\],\s*false\);\s*me\.showLogin\(\);)") + + +def digest(data): + return hashlib.sha256(data).hexdigest() + + +def write(path, data, mode=0o600, owner=None): + fd, tmp = tempfile.mkstemp(dir=path.parent) + try: + with os.fdopen(fd, 'wb') as stream: + stream.write(data) + stream.flush() + os.fsync(stream.fileno()) + os.chmod(tmp, mode) + if owner is not None: + os.chown(tmp, *owner) + os.replace(tmp, path) + finally: + if os.path.exists(tmp): + os.unlink(tmp) + + +def render(text, realm, endpoint, client, redirect): + if MARK in text or len(list(ANCHOR.finditer(text))) != 1: + raise ValueError('Unbekannter oder mehrdeutiger Logout-Code; keine Änderung.') + for url in (endpoint, redirect): + u = urlsplit(url) + if u.scheme != 'https' or not u.hostname or u.username or u.password or u.fragment or u.query: + raise ValueError('Nur feste HTTPS-URLs ohne Query/Zugangsdaten erlaubt.') + cfg = json.dumps(dict(realm=realm, endpoint=endpoint, client=client, redirect=redirect), ensure_ascii=True) + def replace(match): + return (match[1] + '\n' + MARK + '\n' + 'const pveIdmUser = Proxmox.UserName || "";\n' + 'const pveIdmConfig = ' + cfg + ';\n' + match[2] + '\n' + 'if (pveIdmUser.endsWith("@" + pveIdmConfig.realm)) {\n' + ' const pveIdmUrl = new URL(pveIdmConfig.endpoint);\n' + ' pveIdmUrl.searchParams.set("client_id", pveIdmConfig.client);\n' + ' pveIdmUrl.searchParams.set("post_logout_redirect_uri", pveIdmConfig.redirect);\n' + ' window.setTimeout(function () { window.location.assign(pveIdmUrl.href); }, 0);\n' + '}\n/* END PVE-IDM LOGOUT v1 */\n') + return ANCHOR.sub(replace, text) + + +def apply(target, directory, enabled, version='', realm='', endpoint='', client='', redirect=''): + if target.is_symlink() or not target.is_file(): + raise ValueError('JavaScript-Ziel muss eine reguläre Datei sein.') + current = target.read_bytes() + statefile = directory / 'state.json' + state = json.loads(statefile.read_text()) if statefile.exists() else None + base = current + if MARK.encode() in current: + if not state or state['patched_sha256'] != digest(current) or state['target'] != str(target): + raise ValueError('Veränderter Patch oder fehlende Sicherungsdaten; automatischer Eingriff gestoppt.') + base = (directory / state['backup']).read_bytes() + if digest(base) != state['original_sha256']: + raise ValueError('Sicherung beschädigt; keine Änderung.') + elif not enabled: + return False # Already removed by a package update: never restore an old bundle. + if enabled: + if not re.search(r'pve-manager/9\.', version): + raise ValueError('Nur PVE 9 wird unterstützt.') + for suffix in ('.gz', '.br'): + if Path(str(target) + suffix).exists(): + raise ValueError('Vorkomprimiertes JS gefunden; Auslieferung zuerst prüfen.') + desired = render(base.decode(), realm, endpoint, client, redirect).encode() + else: + desired = base + if desired == current: + return False + directory.mkdir(parents=True, exist_ok=True, mode=0o700) + stat = target.stat() + if enabled: + backup = digest(base) + '.js.orig' + backupfile = directory / backup + if backupfile.exists() and backupfile.read_bytes() != base: + raise ValueError('Sicherungskollision.') + if not backupfile.exists(): + write(backupfile, base) + # Save recovery metadata before replacing the target; inconsistent states fail closed. + write(statefile, json.dumps(dict(target=str(target), backup=backup, + original_sha256=digest(base), patched_sha256=digest(desired), version=version)).encode()) + write(target, desired, stat.st_mode & 0o777, (stat.st_uid, stat.st_gid)) + return True + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--target', required=True) + parser.add_argument('--state-dir', required=True) + parser.add_argument('--enabled', choices=['true', 'false'], required=True) + for option in ('version', 'realm', 'endpoint', 'client', 'redirect'): + parser.add_argument('--' + option, default='') + args = vars(parser.parse_args()) + args['target'] = Path(args['target']) + args['directory'] = Path(args.pop('state_dir')) + args['enabled'] = args['enabled'] == 'true' + try: + print(json.dumps({'changed': apply(**args)})) + except (ValueError, OSError, KeyError) as exc: + parser.exit(1, str(exc) + '\n') diff --git a/PVE-IDM/setup.py b/PVE-IDM/setup.py index 1cf163d..143c73a 100644 --- a/PVE-IDM/setup.py +++ b/PVE-IDM/setup.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 """Interactive configuration for PVE-IDM; Python standard library only.""" +import argparse import getpass import ipaddress import json @@ -157,6 +158,39 @@ def atomic_write(path, content): os.unlink(temporary) +def rollback_logout(): + """Remove the remote patch and disable reinstallation in local configuration.""" + os.chdir(ROOT) + executable = shutil.which('ansible-playbook') + if not executable: + raise RuntimeError('Ansible fehlt. Bitte zuerst die Ansible-Python-Umgebung aktivieren.') + config_path = ROOT / 'group_vars/all.yml' + if not config_path.is_file(): + raise RuntimeError('group_vars/all.yml fehlt. Für eine manuelle Installation den Rückbau-Befehl aus der README direkt auf PVE verwenden.') + try: + import yaml + config = yaml.safe_load(config_path.read_text()) + except (ImportError, ValueError) as exc: + raise RuntimeError('Konfiguration kann nicht gelesen werden. Bitte die Ansible-Python-Umgebung verwenden.') from exc + if not isinstance(config, dict): + raise RuntimeError('group_vars/all.yml muss eine YAML-Zuordnung enthalten.') + inventory_default = 'inventory/hosts.local.yml' if (ROOT / 'inventory/hosts.local.yml').exists() else 'inventory/hosts.yml' + inventory = ask('Inventory für den Rückbau', inventory_default, local_file) + command = [executable, '-i', str(Path(inventory).expanduser().resolve()), 'playbook/logout-remove.yml'] + if yes('SSH-Passwort abfragen?'): + command.append('--ask-pass') + if yes('sudo-Passwort abfragen?'): + command.append('--ask-become-pass') + print('Entfernt nur den verwalteten PVE-Logout-Patch. Keycloak/OIDC und Sicherungen bleiben erhalten.') + if not yes('Logout-Patch auf den PVE-Hosts dieses Inventory jetzt zurückbauen?'): + print('Abgebrochen; keine Änderung.') + return + subprocess.run(command, check=True) + config['pve_logout_enabled'] = False + atomic_write(config_path, yaml.safe_dump(config, allow_unicode=True, sort_keys=False).encode()) + print('Rückbau abgeschlossen; pve_logout_enabled=false gespeichert. PVE im Browser vollständig neu laden.') + + def main(): os.chdir(ROOT) if not sys.stdin.isatty(): @@ -197,6 +231,9 @@ def main(): https_url(url.strip(), root=True) config['pve_redirect_uris'] = list(dict.fromkeys(u.strip() for u in ask( 'PVE-Browser-URLs, mehrere mit Komma trennen', 'https://ts01.heim.lan:8006/', redirects).split(','))) + config['pve_logout_enabled'] = yes('PVE-Logout zu Keycloak weiterleiten (optionaler WebUI-Patch)?', True) + config['pve_logout_redirect_uri'] = ask('Rücksprung nach Keycloak-Logout', config['pve_redirect_uris'][0], + lambda v: None if v in config['pve_redirect_uris'] else invalid('Eine der angegebenen PVE-Browser-URLs wählen.')) print('\nSessions in Sekunden: 900 = 15 Minuten; 28800 = 8 Stunden') while True: for key, label, default in [ @@ -271,7 +308,13 @@ def main(): if __name__ == '__main__': try: - main() + parser = argparse.ArgumentParser(description='PVE-IDM Einrichtung und Logout-Rückbau') + parser.add_argument('--rollback-logout', action='store_true', help='Logout-Patch entfernen und lokal deaktivieren') + args = parser.parse_args() + if args.rollback_logout: + rollback_logout() + else: + main() except (KeyboardInterrupt, EOFError): print('\nAbgebrochen.', file=sys.stderr) sys.exit(130) diff --git a/PVE-IDM/tasks/keycloak.yml b/PVE-IDM/tasks/keycloak.yml index 4bfd006..9951522 100644 --- a/PVE-IDM/tasks/keycloak.yml +++ b/PVE-IDM/tasks/keycloak.yml @@ -9,6 +9,10 @@ unredirected_headers: [Authorization] timeout: 30 block: + - name: Validate optional logout redirect before API changes + ansible.builtin.assert: + that: pve_logout_redirect_uri in pve_redirect_uris + when: pve_logout_enabled | default(false) | bool - name: Obtain short-lived admin token ansible.builtin.uri: url: "{{ keycloak_base_url }}/realms/{{ keycloak_admin_realm }}/protocol/openid-connect/token" @@ -100,6 +104,10 @@ kc_session_attributes: client.session.idle.timeout: "{{ keycloak_client_idle | string }}" client.session.max.lifespan: "{{ keycloak_client_max | string }}" + - name: Register explicit post-logout return address + ansible.builtin.set_fact: + kc_session_attributes: "{{ kc_session_attributes | combine({'post.logout.redirect.uris': pve_logout_redirect_uri}) }}" + when: pve_logout_enabled | default(false) | bool - name: Create confidential PVE client ansible.builtin.uri: url: "{{ kc_api }}/clients" diff --git a/PVE-IDM/tasks/logout.yml b/PVE-IDM/tasks/logout.yml new file mode 100644 index 0000000..6979c92 --- /dev/null +++ b/PVE-IDM/tasks/logout.yml @@ -0,0 +1,60 @@ +- name: Reject unsupported patch dry-run + ansible.builtin.assert: + that: not ansible_check_mode + fail_msg: 'Logout-Patch bitte regulär ausführen; --check wird nicht unterstützt.' +- name: Read installed PVE version + ansible.builtin.command: pveversion + register: logout_version + changed_when: false + when: pve_logout_enabled | default(false) | bool +- name: Validate logout return address + ansible.builtin.assert: + that: + - pve_logout_redirect_uri in pve_redirect_uris + fail_msg: 'Logout-Rücksprung muss einer konfigurierten PVE-Browser-URL entsprechen.' + when: pve_logout_enabled | default(false) | bool +- name: Discover verified Keycloak logout endpoint + ansible.builtin.uri: + url: "{{ pve_oidc_issuer }}/.well-known/openid-configuration" + validate_certs: true + ca_path: "{{ system_ca_bundle }}" + use_proxy: false + follow_redirects: none + register: logout_discovery + when: pve_logout_enabled | default(false) | bool +- name: Validate discovered endpoint and issuer + ansible.builtin.assert: + that: + - logout_discovery.json.issuer == pve_oidc_issuer + - logout_discovery.json.end_session_endpoint == pve_oidc_issuer ~ '/protocol/openid-connect/logout' + when: pve_logout_enabled | default(false) | bool +- name: Install guarded patch helper + ansible.builtin.copy: + src: ../scripts/logout_patch.py + dest: /usr/local/sbin/pve-idm-logout-patch + owner: root + group: root + mode: '0700' +- name: Apply or remove managed desktop logout patch + ansible.builtin.command: + argv: + - python3 + - /usr/local/sbin/pve-idm-logout-patch + - --target + - /usr/share/pve-manager/js/pvemanagerlib.js + - --state-dir + - /var/lib/pve-idm/logout + - --enabled + - "{{ (pve_logout_enabled | default(false) | bool) | ternary('true', 'false') }}" + - --version + - "{{ logout_version.stdout | default('') }}" + - --realm + - "{{ pve_realm }}" + - --endpoint + - "{{ (logout_discovery.json | default({})).get('end_session_endpoint', '') }}" + - --client + - "{{ keycloak_client_id }}" + - --redirect + - "{{ pve_logout_redirect_uri | default('') }}" + register: logout_patch_result + changed_when: (logout_patch_result.stdout | from_json).changed diff --git a/PVE-IDM/tests/test_logout.py b/PVE-IDM/tests/test_logout.py new file mode 100644 index 0000000..d460463 --- /dev/null +++ b/PVE-IDM/tests/test_logout.py @@ -0,0 +1,101 @@ +import importlib.util +from pathlib import Path +import tempfile +import json +import shutil +import subprocess +import unittest + +spec = importlib.util.spec_from_file_location('patch', Path(__file__).resolve().parents[1] / 'scripts/logout_patch.py') +patch = importlib.util.module_from_spec(spec) +spec.loader.exec_module(patch) +FIXTURE = """text: gettext('Logout'), +handler: function () { + PVE.data.ResourceStore.loadData([], false); + me.showLogin(); + cleanup(); +},""" + + +class LogoutTests(unittest.TestCase): + def test_lifecycle_and_update(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + target = root / 'bundle.js' + target.write_text(FIXTURE) + args = dict(target=target, directory=root / 'state', enabled=True, + version='pve-manager/9.0.0/test', realm='main.heim.lan', + endpoint='https://kc:8443/realms/main/protocol/openid-connect/logout', + client='PVE-SERVER', redirect='https://ts01:8006/') + self.assertTrue(patch.apply(**args)) + self.assertFalse(patch.apply(**args)) + self.assertIn('pveIdmUser.endsWith', target.read_text()) + self.assertLess(target.read_text().index('me.showLogin();'), target.read_text().index('window.setTimeout')) + args['client'] = 'OTHER' + self.assertTrue(patch.apply(**args)) + self.assertTrue(patch.apply(target, root / 'state', False)) + self.assertEqual(target.read_text(), FIXTURE) + self.assertFalse(patch.apply(target, root / 'state', False)) + patch.apply(**args) + # Package update replaced the entire file; rollback must not downgrade it. + target.write_text(FIXTURE + '\n// new package') + self.assertFalse(patch.apply(target, root / 'state', False)) + self.assertTrue(patch.apply(**args)) + self.assertTrue(patch.apply(target, root / 'state', False)) + self.assertEqual(target.read_text(), FIXTURE + '\n// new package') + + def test_unknown_code_rejected(self): + for text in ('unknown', FIXTURE + FIXTURE): + with self.assertRaises(ValueError): + patch.render(text, 'realm', 'https://kc/logout', 'client', 'https://pve/') + + def test_tamper_rejected(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + target = root / 'bundle.js' + target.write_text(FIXTURE) + patch.apply(target, root / 'state', True, 'pve-manager/9.1/x', 'realm', + 'https://kc/logout', 'client', 'https://pve/') + target.write_text(target.read_text() + '// manual edit') + with self.assertRaises(ValueError): + patch.apply(target, root / 'state', False) + + @unittest.skipUnless(shutil.which('node'), 'Node.js not installed') + def test_browser_handler_order_and_realm(self): + code = patch.render(FIXTURE, 'main.heim.lan', 'https://kc/logout', 'PVE-SERVER', 'https://ts01:8006/') + javascript = r""" +const vm = require('vm'); +const source = CODE; +for (const user of ['alice@main.heim.lan', 'root@pam']) { + const events = []; const timers = []; + const context = {URL, gettext: x => x, + Proxmox: {UserName: user}, + PVE: {data: {ResourceStore: {loadData: () => events.push('clear')}}}, + me: {showLogin: () => { events.push('local'); context.Proxmox.UserName = null; }}, + cleanup: () => events.push('cleanup'), + window: {setTimeout: f => timers.push(f), location: {assign: u => events.push(u)}}}; + vm.runInNewContext('({' + source + '}).handler()', context); + if (events.join(',') !== 'clear,local,cleanup') throw Error('Local cleanup/order failed'); + timers.forEach(f => f()); + if (user === 'root@pam' && events.length !== 3) throw Error('PAM redirected'); + if (user.startsWith('alice')) { + const url = new URL(events[3]); + if (url.origin !== 'https://kc' || url.searchParams.get('client_id') !== 'PVE-SERVER' + || url.searchParams.get('post_logout_redirect_uri') !== 'https://ts01:8006/') throw Error('Wrong redirect'); + } +} +""".replace('CODE', json.dumps(code)) + subprocess.run([shutil.which('node'), '-e', javascript], check=True, capture_output=True) + + def test_wrong_version_no_write(self): + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + target = root / 'bundle.js' + target.write_text(FIXTURE) + with self.assertRaises(ValueError): + patch.apply(target, root / 'state', True, 'pve-manager/10.0/x') + self.assertEqual(target.read_text(), FIXTURE) + + +if __name__ == '__main__': + unittest.main() diff --git a/PVE-IDM/tests/test_setup.py b/PVE-IDM/tests/test_setup.py index 0addf5a..5d6a3de 100644 --- a/PVE-IDM/tests/test_setup.py +++ b/PVE-IDM/tests/test_setup.py @@ -5,6 +5,7 @@ import shutil import subprocess import tempfile import unittest +from unittest.mock import patch spec = importlib.util.spec_from_file_location('wizard', Path(__file__).resolve().parents[1] / 'setup.py') wizard = importlib.util.module_from_spec(spec) @@ -35,6 +36,28 @@ class SetupTests(unittest.TestCase): self.assertEqual(target.stat().st_mode & 0o777, 0o600) self.assertEqual(len(list(Path(folder).iterdir())), 1) + def test_rollback_success_and_failure(self): + for fail in (False, True): + with tempfile.TemporaryDirectory() as folder: + root = Path(folder) + (root / 'group_vars').mkdir() + config = root / 'group_vars/all.yml' + config.write_text('pve_logout_enabled: true\npve_realm: main.heim.lan\n') + previous = Path.cwd() + try: + with patch.object(wizard, 'ROOT', root), patch.object(wizard.shutil, 'which', return_value='/test/ansible-playbook'), patch.object(wizard, 'ask', return_value='inventory.yml'), patch.object(wizard, 'yes', side_effect=[False, False, True]), patch.object(wizard.subprocess, 'run') as run: + if fail: + run.side_effect = subprocess.CalledProcessError(1, 'test') + with self.assertRaises(subprocess.CalledProcessError): + wizard.rollback_logout() + self.assertIn('pve_logout_enabled: true', config.read_text()) + else: + wizard.rollback_logout() + self.assertIn('pve_logout_enabled: false', config.read_text()) + self.assertNotIn('--ask-vault-pass', run.call_args.args[0]) + finally: + os.chdir(previous) + @unittest.skipUnless(shutil.which('ansible-vault'), 'ansible-vault not installed') def test_real_vault_roundtrip(self): payload = {'test': 'fake-test-value-with-umlaut-ä'}