diff --git a/cluster/cluster_api.py b/cluster/cluster_api.py index 7438bdb..7f83da8 100644 --- a/cluster/cluster_api.py +++ b/cluster/cluster_api.py @@ -10,6 +10,7 @@ from django.views.decorators.http import require_GET, require_POST from cluster.models import ClusterSettings, Worker, WorkerStatus from cluster.sync import SECTION_NAMES, build_manifest, build_section +from gatekeeper.sessions import clean_gateway_sessions REPORT_STATUS_FIELDS = ('status', 'message') @@ -160,6 +161,11 @@ def api_report(request): worker_status.certificate_status_updated = timezone.now() update_fields += ['certificate_status', 'certificate_status_updated'] + if isinstance(payload.get('gateway_sessions'), list): + worker_status.gateway_sessions = clean_gateway_sessions(payload['gateway_sessions']) + worker_status.gateway_sessions_updated = timezone.now() + update_fields += ['gateway_sessions', 'gateway_sessions_updated'] + if isinstance(payload.get('wireguard_status'), dict): worker_status.wireguard_status = payload['wireguard_status'] worker_status.wireguard_status_updated = timezone.now() diff --git a/cluster/migrations/0020_workerstatus_gateway_sessions_and_more.py b/cluster/migrations/0020_workerstatus_gateway_sessions_and_more.py new file mode 100644 index 0000000..41b4cc7 --- /dev/null +++ b/cluster/migrations/0020_workerstatus_gateway_sessions_and_more.py @@ -0,0 +1,23 @@ +# Generated by Django 5.2.19 on 2026-11-21 18:56 + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('cluster', '0019_alter_clustersettings_cluster_mode'), + ] + + operations = [ + migrations.AddField( + model_name='workerstatus', + name='gateway_sessions', + field=models.JSONField(blank=True, default=list), + ), + migrations.AddField( + model_name='workerstatus', + name='gateway_sessions_updated', + field=models.DateTimeField(blank=True, null=True), + ), + ] diff --git a/cluster/models.py b/cluster/models.py index 4e96cbd..ad6095b 100644 --- a/cluster/models.py +++ b/cluster/models.py @@ -120,6 +120,9 @@ class WorkerStatus(models.Model): # {hostname: {"status": ..., "issuer": ..., "not_after": ..., "generation": ...}} certificate_status = models.JSONField(default=dict, blank=True) certificate_status_updated = models.DateTimeField(blank=True, null=True) + # Active sessions of the auth-gateway of the worker, as published in its sessions snapshot + gateway_sessions = models.JSONField(default=list, blank=True) + gateway_sessions_updated = models.DateTimeField(blank=True, null=True) updated = models.DateTimeField(auto_now=True) created = models.DateTimeField(auto_now_add=True) diff --git a/cluster/sync.py b/cluster/sync.py index 9208cf8..8ccb1db 100644 --- a/cluster/sync.py +++ b/cluster/sync.py @@ -15,6 +15,7 @@ from cluster.models import ClusterSettings, WorkerStatus from dns.functions import generate_dnsmasq_config from dns.models import DNSFilterList from firewall.tools import generate_firewall_script +from gatekeeper.sessions import REVOKED_SESSIONS_FILE, build_revoked_sessions_data from wireguard.models import WireGuardInstance from wireguard_tools.functions import CLUSTER_WIREGUARD_CONFIG_DIR, WIREGUARD_CONFIG_DIR @@ -143,6 +144,8 @@ def build_gateway_section(worker): section = Section() for file_name, data in get_gateway_export(worker).items(): section.add_file(file_name, json.dumps(data, indent=2) + '\n') + # Sessions ended from the WireGuard WebAdmin, the same for every server + section.add_file(REVOKED_SESSIONS_FILE, json.dumps(build_revoked_sessions_data(), indent=2) + '\n') return section diff --git a/cluster/tests.py b/cluster/tests.py index 1e5bb16..6726174 100644 --- a/cluster/tests.py +++ b/cluster/tests.py @@ -22,6 +22,7 @@ from firewall.tools import generate_firewall_script from user_manager.models import UserAcl from wireguard.models import Peer, PeerAllowedIP, WireGuardInstance from wireguard_tools.functions import get_config_servers +from wireguard_tools.tests import load_cluster_worker from wireguard_tools.views import export_wireguard_configuration, generate_peer_config FAKE_CERTIFICATE = '-----BEGIN CERTIFICATE-----\nfake\n-----END CERTIFICATE-----\n' @@ -138,6 +139,25 @@ class ClusterApiTests(ClusterTestMixin, TestCase): self.assertIsNotNone(worker_status.certificate_status_updated) self.assertIsNotNone(worker_status.wireguard_status_updated) + def test_report_stores_gateway_sessions(self): + sessions = [ + {'id': 'a' * 64, 'username': 'alice', 'factors': ['password'], 'online': True, 'session_id': 'secret'}, + {'id': 'invalid', 'username': 'mallory'}, + ] + response = self.client.post( + '/api/cluster/v2/report/', data=json.dumps({'gateway_sessions': sessions}), content_type='application/json', + **self.headers + ) + self.assertEqual(response.status_code, 200) + worker_status = WorkerStatus.objects.get(worker=self.worker) + self.assertEqual([session['id'] for session in worker_status.gateway_sessions], ['a' * 64]) + self.assertNotIn('session_id', worker_status.gateway_sessions[0]) + self.assertIsNotNone(worker_status.gateway_sessions_updated) + + # A report without sessions (older worker or no change) keeps the last ones + self.client.post('/api/cluster/v2/report/', data=json.dumps({'services': {}}), content_type='application/json', **self.headers) + self.assertEqual(len(WorkerStatus.objects.get(worker=self.worker).gateway_sessions), 1) + class ClusterSyncTests(ClusterTestMixin, TestCase): def report_sections(self, manifest, overrides=None): @@ -435,3 +455,73 @@ class DistributedModeTests(ClusterTestMixin, TestCase): self.client.get(f'/cluster/worker/manage/?uuid={self.worker_b.uuid}&action=delete&confirmation=delete') self.assertFalse(Worker.objects.filter(pk=self.worker_b.pk).exists()) + + +class AgentGatewaySessionsTests(TestCase): + """Sessions of the node auth-gateway are reported when they change, and revocations reach its config.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.cluster_worker = load_cluster_worker() + + def setUp(self): + temp_dir = tempfile.TemporaryDirectory() + self.addCleanup(temp_dir.cleanup) + self.gateway_dir = temp_dir.name + self.sessions_file = os.path.join(self.gateway_dir, 'state', 'sessions.json') + os.makedirs(os.path.dirname(self.sessions_file)) + for name, value in ( + ('GATEWAY_DIR', self.gateway_dir), + ('GATEWAY_SESSIONS_FILE', self.sessions_file), + ('gateway_enabled', lambda: True), + ('wireguard_status', lambda: {}), + ): + patcher = patch.object(self.cluster_worker, name, value) + patcher.start() + self.addCleanup(patcher.stop) + for name in ('services_status', 'certificates_status'): + patcher = patch.object(self.cluster_worker.ClusterNodeAgent, name, staticmethod(lambda: {})) + patcher.start() + self.addCleanup(patcher.stop) + self.agent = self.cluster_worker.ClusterNodeAgent() + self.reports = [] + self.status_code = 200 + self.agent.request = self.record_report + + def record_report(self, method, path, json=None): + self.reports.append(json) + return type('Response', (), {'status_code': self.status_code})() + + def publish(self, sessions): + with open(self.sessions_file, 'w', encoding='utf-8') as sessions_file: + sessions_file.write(json.dumps({'sessions': sessions})) + + def test_sessions_are_only_reported_when_they_change(self): + self.publish([{'id': 'a' * 64}]) + self.agent.send_stats() + self.agent.send_stats() + self.publish([]) + self.agent.send_stats() + self.assertEqual([report.get('gateway_sessions') for report in self.reports], [[{'id': 'a' * 64}], None, []]) + + def test_sessions_are_reported_again_when_the_primary_did_not_accept_them(self): + self.publish([{'id': 'a' * 64}]) + self.status_code = 500 + self.agent.send_stats() + self.status_code = 200 + self.agent.send_stats() + self.agent.send_stats() + self.assertEqual(['gateway_sessions' in report for report in self.reports], [True, True, False]) + + def test_no_sessions_file_reports_nothing(self): + self.agent.send_stats() + self.assertNotIn('gateway_sessions', self.reports[0]) + + def test_revoked_sessions_are_written_when_sent(self): + files = {name: '{}' for name in self.cluster_worker.GATEWAY_FILES} + self.agent.apply_gateway({'files': files}) + self.assertFalse(os.path.exists(os.path.join(self.gateway_dir, 'revoked_sessions.json'))) + self.agent.apply_gateway({'files': dict(files, **{'revoked_sessions.json': '{"sessions": []}'})}) + with open(os.path.join(self.gateway_dir, 'revoked_sessions.json'), encoding='utf-8') as revoked_file: + self.assertEqual(revoked_file.read(), '{"sessions": []}') diff --git a/containers/auth-gateway/auth_gateway/config_loader.py b/containers/auth-gateway/auth_gateway/config_loader.py index ee45e1c..e0d156b 100644 --- a/containers/auth-gateway/auth_gateway/config_loader.py +++ b/containers/auth-gateway/auth_gateway/config_loader.py @@ -96,9 +96,16 @@ def load_runtime_config(config_dir: Path) -> RuntimeConfig: users=auth.users, groups=auth.groups, policies=auth.policies, + revoked_sessions=_load_revoked_sessions(config_dir), ) +def _load_revoked_sessions(config_dir: Path) -> set[str]: + payload = _load_json(config_dir / "revoked_sessions.json") or {} + sessions = payload.get("sessions", []) if isinstance(payload, dict) else [] + return {value for value in sessions if isinstance(value, str)} + + class RuntimeConfigStore: def __init__(self, config_dir: Path): self.config_dir = config_dir @@ -112,6 +119,7 @@ class RuntimeConfigStore: "applications.json", "routes.json", "auth_policies.json", + "revoked_sessions.json", ): path = self.config_dir / filename if path.exists(): diff --git a/containers/auth-gateway/auth_gateway/main.py b/containers/auth-gateway/auth_gateway/main.py index e615836..e9c62c1 100644 --- a/containers/auth-gateway/auth_gateway/main.py +++ b/containers/auth-gateway/auth_gateway/main.py @@ -1,3 +1,4 @@ +import asyncio import logging import time from contextlib import asynccontextmanager @@ -13,6 +14,7 @@ from auth_gateway.config_loader import RuntimeConfigStore from auth_gateway.limiter import get_real_client_ip, limiter from auth_gateway.services.oidc_service import OIDCService from auth_gateway.services.session_service import SessionService +from auth_gateway.services.session_snapshot import SNAPSHOT_INTERVAL_SECONDS, SessionSnapshot from auth_gateway.settings import settings from auth_gateway.storage.sqlite import SQLiteStorage from auth_gateway.web.auth_routes import router as auth_router @@ -31,7 +33,20 @@ async def lifespan(app: FastAPI): app.state.session_service = SessionService(storage, settings.session_default_minutes, settings.oidc_state_ttl_minutes) app.state.oidc_service = OIDCService() app.state.templates = Jinja2Templates(directory=str(BASE_DIR / "templates")) + app.state.session_snapshot = SessionSnapshot(storage, app.state.config_store, settings.config_dir / "state" / "sessions.json") + snapshot_task = asyncio.create_task(_refresh_session_snapshot(app.state.session_snapshot)) yield + snapshot_task.cancel() + + +async def _refresh_session_snapshot(session_snapshot: SessionSnapshot): + # Sessions also end without a request (expiration, revocation, changed credentials) and go offline over time + while True: + try: + await asyncio.to_thread(session_snapshot.refresh) + except Exception as error: + _access_logger.warning("Session snapshot failed: %s", error) + await asyncio.sleep(SNAPSHOT_INTERVAL_SECONDS) app = FastAPI( diff --git a/containers/auth-gateway/auth_gateway/models/runtime.py b/containers/auth-gateway/auth_gateway/models/runtime.py index 169074a..eb39467 100644 --- a/containers/auth-gateway/auth_gateway/models/runtime.py +++ b/containers/auth-gateway/auth_gateway/models/runtime.py @@ -1,7 +1,8 @@ +from pydantic import BaseModel, Field + from auth_gateway.models.applications import ApplicationModel from auth_gateway.models.auth import AuthMethodModel, GroupModel, PolicyModel, UserModel from auth_gateway.models.routes import AppRoutesModel -from pydantic import BaseModel, Field class RuntimeConfig(BaseModel): @@ -11,3 +12,5 @@ class RuntimeConfig(BaseModel): users: dict[str, UserModel] = Field(default_factory=dict) groups: dict[str, GroupModel] = Field(default_factory=dict) policies: dict[str, PolicyModel] = Field(default_factory=dict) + # sha256 of the IDs of sessions ended from the WireGuard WebAdmin + revoked_sessions: set[str] = Field(default_factory=set) diff --git a/containers/auth-gateway/auth_gateway/services/session_service.py b/containers/auth-gateway/auth_gateway/services/session_service.py index 172ae26..ec77de4 100644 --- a/containers/auth-gateway/auth_gateway/services/session_service.py +++ b/containers/auth-gateway/auth_gateway/services/session_service.py @@ -1,9 +1,37 @@ +import hashlib from datetime import UTC, datetime, timedelta from secrets import token_urlsafe +from auth_gateway.models.auth import UserModel +from auth_gateway.models.runtime import RuntimeConfig from auth_gateway.models.session import OIDCStateRecord, SessionRecord from auth_gateway.storage.sqlite import SQLiteStorage +# The last access is written at most this often, so requests do not write to the database +LAST_SEEN_WRITE_INTERVAL = timedelta(minutes=5) + + +def session_id_hash(session_id: str) -> str: + """Identifies a session outside the gateway (snapshot, revocation) without exposing the session ID.""" + return hashlib.sha256(session_id.encode()).hexdigest() + + +def credential_fingerprint(user: UserModel) -> str: + """Changes when the password or the TOTP secret of the user changes.""" + value = f"{user.password_hash or ''}\0{user.totp_secret or ''}" + return hashlib.sha256(value.encode()).hexdigest()[:32] + + +def session_is_valid(session: SessionRecord, runtime_config: RuntimeConfig) -> bool: + """A session ends when it is revoked or when the credentials of its user change or the user is removed.""" + if session_id_hash(session.session_id) in runtime_config.revoked_sessions: + return False + if session.username: + user = runtime_config.users.get(session.username) + if not user or session.metadata.get("credential") != credential_fingerprint(user): + return False + return True + class SessionService: def __init__(self, storage: SQLiteStorage, default_session_minutes: int, oidc_state_ttl_minutes: int): @@ -66,6 +94,15 @@ class SessionService: self.storage.save_session(session) return session + def touch(self, session: SessionRecord) -> None: + """Record the last access, at most once per LAST_SEEN_WRITE_INTERVAL.""" + now = datetime.now(UTC) + last_seen = session.metadata.get("last_seen") + if last_seen and now - datetime.fromisoformat(last_seen) < LAST_SEEN_WRITE_INTERVAL: + return + session.metadata["last_seen"] = now.isoformat() + self.storage.save_session(session) + def delete_session(self, session_id: str | None) -> None: if session_id: self.storage.delete_session(session_id) diff --git a/containers/auth-gateway/auth_gateway/services/session_snapshot.py b/containers/auth-gateway/auth_gateway/services/session_snapshot.py new file mode 100644 index 0000000..20bf761 --- /dev/null +++ b/containers/auth-gateway/auth_gateway/services/session_snapshot.py @@ -0,0 +1,80 @@ +import json +import logging +import os +import threading +from datetime import UTC, datetime, timedelta +from pathlib import Path + +from auth_gateway.config_loader import RuntimeConfigStore +from auth_gateway.models.session import SessionRecord +from auth_gateway.services.session_service import session_id_hash, session_is_valid +from auth_gateway.storage.sqlite import SQLiteStorage + +logger = logging.getLogger("uvicorn.error") + +SNAPSHOT_INTERVAL_SECONDS = 30 +# A session used in the last minutes is online. The last access is written at most every 5 minutes, so the window +# must be longer than that. +ONLINE_WINDOW = timedelta(minutes=10) + + +class SessionSnapshot: + """ + Active sessions published for the WireGuard WebAdmin (read by Django on the primary server and reported by the + cluster agent on workers). The file is only rewritten when its content changes: an active session is published + as online without a timestamp, so using it does not change the snapshot. + """ + + def __init__(self, storage: SQLiteStorage, config_store: RuntimeConfigStore, path: Path): + self.storage = storage + self.config_store = config_store + self.path = path + self._lock = threading.Lock() + self._written = None + + @staticmethod + def _entry(session: SessionRecord, now: datetime) -> dict: + last_seen = session.metadata.get("last_seen") or session.created_at.isoformat() + online = now - datetime.fromisoformat(last_seen) < ONLINE_WINDOW + entry = { + "id": session_id_hash(session.session_id), + "username": session.username or "", + "email": session.email or "", + "groups": session.groups, + "factors": session.auth_factors, + "host": session.metadata.get("host", ""), + "client_ip": session.metadata.get("client_ip", ""), + "user_agent": session.metadata.get("user_agent", ""), + "created_at": session.created_at.isoformat(), + "expires_at": session.expires_at.isoformat(), + "online": online, + } + if not online: + entry["last_seen"] = last_seen + return entry + + def refresh(self) -> None: + with self._lock: + now = datetime.now(UTC) + self.storage.delete_expired(now) + try: + runtime_config = self.config_store.get() + except Exception as error: + logger.warning("Session snapshot skipped: configuration not loaded (%s)", error) + return + + entries = [] + for session in self.storage.list_sessions(): + if not session_is_valid(session, runtime_config): + self.storage.delete_session(session.session_id) + continue + entries.append(self._entry(session, now)) + + content = json.dumps({"sessions": entries}, indent=2, sort_keys=True) + "\n" + if content == self._written: + return + self.path.parent.mkdir(parents=True, exist_ok=True) + temp_path = self.path.with_name(f"{self.path.name}.tmp") + temp_path.write_text(content, encoding="utf-8") + os.replace(temp_path, self.path) + self._written = content diff --git a/containers/auth-gateway/auth_gateway/storage/sqlite.py b/containers/auth-gateway/auth_gateway/storage/sqlite.py index 1df4b45..3aebe81 100644 --- a/containers/auth-gateway/auth_gateway/storage/sqlite.py +++ b/containers/auth-gateway/auth_gateway/storage/sqlite.py @@ -92,6 +92,9 @@ class SQLiteStorage: ).fetchone() if not row: return None + return self._session_from_row(row) + + def _session_from_row(self, row: sqlite3.Row) -> SessionRecord: return SessionRecord( session_id=row["session_id"], created_at=self._from_iso(row["created_at"]), @@ -105,6 +108,17 @@ class SQLiteStorage: metadata=json.loads(row["metadata_json"]), ) + def list_sessions(self) -> list[SessionRecord]: + with self._lock, self._connect() as connection: + rows = connection.execute("SELECT * FROM sessions ORDER BY created_at").fetchall() + return [self._session_from_row(row) for row in rows] + + def delete_expired(self, now: datetime) -> None: + with self._lock, self._connect() as connection: + connection.execute("DELETE FROM sessions WHERE expires_at <= ?", (self._to_iso(now),)) + connection.execute("DELETE FROM oidc_states WHERE expires_at <= ?", (self._to_iso(now),)) + connection.commit() + def delete_session(self, session_id: str) -> None: with self._lock, self._connect() as connection: connection.execute("DELETE FROM sessions WHERE session_id = ?", (session_id,)) diff --git a/containers/auth-gateway/auth_gateway/web/auth_routes.py b/containers/auth-gateway/auth_gateway/web/auth_routes.py index efb0bf1..240b096 100644 --- a/containers/auth-gateway/auth_gateway/web/auth_routes.py +++ b/containers/auth-gateway/auth_gateway/web/auth_routes.py @@ -62,6 +62,7 @@ async def auth_check(request: Request): response = PlainTextResponse("OK", status_code=200) response.headers["Cache-Control"] = "no-store" if session: + request.app.state.session_service.touch(session) if session.username: response.headers["X-Auth-User"] = _safe_header(session.username) if session.email: diff --git a/containers/auth-gateway/auth_gateway/web/dependencies.py b/containers/auth-gateway/auth_gateway/web/dependencies.py index 95ed916..75d7999 100644 --- a/containers/auth-gateway/auth_gateway/web/dependencies.py +++ b/containers/auth-gateway/auth_gateway/web/dependencies.py @@ -1,3 +1,4 @@ +from datetime import UTC, datetime from secrets import token_urlsafe from urllib.parse import urlencode @@ -5,11 +6,13 @@ from fastapi import HTTPException, Request from fastapi.responses import Response from auth_gateway.config_loader import RuntimeConfigStore +from auth_gateway.limiter import get_real_client_ip from auth_gateway.models.auth import OIDCMethodModel, TotpMethodModel from auth_gateway.models.runtime import RuntimeConfig from auth_gateway.models.session import SessionRecord from auth_gateway.services.policy_engine import EffectivePolicy, build_effective_policy from auth_gateway.services.resolver import RequestContext, normalize_host, normalize_path, resolve_request_context +from auth_gateway.services.session_service import credential_fingerprint, session_is_valid def get_runtime_config(request: Request) -> RuntimeConfig: @@ -20,7 +23,25 @@ def get_runtime_config(request: Request) -> RuntimeConfig: def get_session(request: Request) -> SessionRecord | None: session_service = request.app.state.session_service cookie_name = request.app.state.settings.cookie_name - return session_service.get_session(request.cookies.get(cookie_name)) + session = session_service.get_session(request.cookies.get(cookie_name)) + if session and not session_is_valid(session, get_runtime_config(request)): + session_service.delete_session(session.session_id) + return None + return session + + +def login_metadata(request: Request, username: str | None = None) -> dict: + """Where the session was opened and, for local users, the fingerprint of their credentials.""" + metadata = { + "host": normalize_host(request.headers.get("host", "")), + "client_ip": get_real_client_ip(request), + "user_agent": request.headers.get("user-agent", "")[:200], + "last_seen": datetime.now(UTC).isoformat(), + } + user = get_runtime_config(request).users.get(username) if username else None + if user: + metadata["credential"] = credential_fingerprint(user) + return metadata def build_external_url(request: Request, path: str, **params: str) -> str: diff --git a/containers/auth-gateway/auth_gateway/web/login_routes.py b/containers/auth-gateway/auth_gateway/web/login_routes.py index ab92fe5..7e213ff 100644 --- a/containers/auth-gateway/auth_gateway/web/login_routes.py +++ b/containers/auth-gateway/auth_gateway/web/login_routes.py @@ -22,6 +22,7 @@ from auth_gateway.web.dependencies import ( get_session, get_session_factors, get_totp_method, + login_metadata, resolve_context_from_request, set_csrf_cookie, session_is_allowed, @@ -54,6 +55,7 @@ def _render(request: Request, template_name: str, status_code: int = 200, **cont def _redirect_with_cookie(request: Request, destination: str, session) -> RedirectResponse: + request.app.state.session_snapshot.refresh() response = RedirectResponse(destination, status_code=303) response.set_cookie( key=request.app.state.settings.cookie_name, @@ -75,7 +77,7 @@ def _create_authenticated_session(request: Request, *, username=None, email=None email=email, subject=subject, groups=groups, - metadata=metadata, + metadata={**login_metadata(request, username), **(metadata or {})}, add_factors=factors, expires_in_minutes=expires_in_minutes, ) @@ -315,7 +317,8 @@ async def login_totp_submit(request: Request, next: str = Form("/"), token: str refreshed_session = session_service.issue_session( existing_session=session, add_factors=["totp"], - metadata=factor_method_metadata(session, "totp", method_name), + # Without a password or OIDC step (TOTP only), the session starts here + metadata={**({} if session else login_metadata(request)), **factor_method_metadata(session, "totp", method_name)}, expires_in_minutes=get_effective_expiration(request, effective_policy, ["totp"]), ) logger.info("AUTH login ok for '%s' via password+totp (policy: %s)", refreshed_session.username, context.policy_name) @@ -393,6 +396,7 @@ def _do_logout(request: Request, next_url: str = "/") -> RedirectResponse: session_cookie = request.cookies.get(request.app.state.settings.cookie_name) session = request.app.state.session_service.get_session(session_cookie) request.app.state.session_service.delete_session(session_cookie) + request.app.state.session_snapshot.refresh() if session: logger.info("AUTH logout for '%s'", session.username or session.email or "unknown") response = RedirectResponse(_safe_redirect_path(next_url), status_code=303) diff --git a/containers/auth-gateway/tests/test_sessions.py b/containers/auth-gateway/tests/test_sessions.py new file mode 100644 index 0000000..e18af05 --- /dev/null +++ b/containers/auth-gateway/tests/test_sessions.py @@ -0,0 +1,147 @@ +import json +import tempfile +import unittest +from datetime import UTC, datetime, timedelta +from pathlib import Path + +from auth_gateway.config_loader import RuntimeConfigStore +from auth_gateway.models.auth import UserModel +from auth_gateway.models.runtime import RuntimeConfig +from auth_gateway.services.session_service import ( + SessionService, + credential_fingerprint, + session_id_hash, + session_is_valid, +) +from auth_gateway.services.session_snapshot import SessionSnapshot +from auth_gateway.storage.sqlite import SQLiteStorage + +ALICE = UserModel(email="alice@example.test", password_hash="hash-1", totp_secret="SECRET-1") + + +def write_config(config_dir: Path, users: dict, revoked: list[str] | None = None) -> None: + (config_dir / "applications.json").write_text(json.dumps({"entries": []})) + (config_dir / "routes.json").write_text(json.dumps({"entries": {}})) + (config_dir / "auth_policies.json").write_text(json.dumps({"users": users})) + if revoked is not None: + (config_dir / "revoked_sessions.json").write_text(json.dumps({"sessions": revoked})) + + +class SessionValidityTests(unittest.TestCase): + def setUp(self): + temp_dir = tempfile.TemporaryDirectory() + self.addCleanup(temp_dir.cleanup) + self.service = SessionService(SQLiteStorage(Path(temp_dir.name) / "sessions.sqlite3"), 720, 10) + self.session = self.service.issue_session( + username="alice", add_factors=["password"], metadata={"credential": credential_fingerprint(ALICE)}, + ) + + def test_session_with_current_credentials_is_valid(self): + self.assertTrue(session_is_valid(self.session, RuntimeConfig(users={"alice": ALICE}))) + + def test_changed_password_or_totp_ends_the_session(self): + for changed in (ALICE.model_copy(update={"password_hash": "hash-2"}), ALICE.model_copy(update={"totp_secret": "SECRET-2"})): + self.assertFalse(session_is_valid(self.session, RuntimeConfig(users={"alice": changed}))) + + def test_removed_user_ends_the_session(self): + self.assertFalse(session_is_valid(self.session, RuntimeConfig(users={}))) + + def test_session_without_credential_fingerprint_is_not_valid(self): + old_session = self.service.issue_session(username="alice", add_factors=["password"]) + self.assertFalse(session_is_valid(old_session, RuntimeConfig(users={"alice": ALICE}))) + + def test_revoked_session_is_not_valid(self): + runtime_config = RuntimeConfig(users={"alice": ALICE}, revoked_sessions={session_id_hash(self.session.session_id)}) + self.assertFalse(session_is_valid(self.session, runtime_config)) + + def test_session_without_local_user_only_checks_revocation(self): + totp_session = self.service.issue_session(add_factors=["totp"]) + self.assertTrue(session_is_valid(totp_session, RuntimeConfig())) + + def test_last_access_is_written_at_most_every_five_minutes(self): + self.session.metadata["last_seen"] = (datetime.now(UTC) - timedelta(minutes=2)).isoformat() + recent = self.session.metadata["last_seen"] + self.service.touch(self.session) + self.assertEqual(self.service.storage.get_session(self.session.session_id).metadata.get("last_seen"), None) + self.assertEqual(self.session.metadata["last_seen"], recent) + + self.session.metadata["last_seen"] = (datetime.now(UTC) - timedelta(minutes=6)).isoformat() + self.service.touch(self.session) + stored = datetime.fromisoformat(self.service.storage.get_session(self.session.session_id).metadata["last_seen"]) + self.assertLess(datetime.now(UTC) - stored, timedelta(seconds=5)) + + +class SessionSnapshotTests(unittest.TestCase): + def setUp(self): + temp_dir = tempfile.TemporaryDirectory() + self.addCleanup(temp_dir.cleanup) + self.config_dir = Path(temp_dir.name) + write_config(self.config_dir, {"alice": ALICE.model_dump()}) + self.storage = SQLiteStorage(self.config_dir / "sessions.sqlite3") + self.service = SessionService(self.storage, 720, 10) + self.snapshot_path = self.config_dir / "state" / "sessions.json" + self.snapshot = SessionSnapshot(self.storage, RuntimeConfigStore(self.config_dir), self.snapshot_path) + + def issue(self, minutes_since_last_access=0): + return self.service.issue_session( + username="alice", email="alice@example.test", groups=["staff"], add_factors=["password"], + metadata={ + "credential": credential_fingerprint(ALICE), + "host": "app.example.test", + "client_ip": "203.0.113.5", + "last_seen": (datetime.now(UTC) - timedelta(minutes=minutes_since_last_access)).isoformat(), + "oidc_claims": {"name": "Alice"}, + }, + ) + + def read(self): + return json.loads(self.snapshot_path.read_text())["sessions"] + + def test_snapshot_lists_sessions_without_session_id_or_claims(self): + session = self.issue() + self.snapshot.refresh() + content = self.snapshot_path.read_text() + entry = self.read()[0] + self.assertEqual(entry["id"], session_id_hash(session.session_id)) + self.assertEqual((entry["username"], entry["host"], entry["client_ip"], entry["online"]), ("alice", "app.example.test", "203.0.113.5", True)) + self.assertNotIn("last_seen", entry) + self.assertNotIn(session.session_id, content) + self.assertNotIn("Alice", content) + + def test_session_unused_for_ten_minutes_is_offline_with_last_access(self): + self.issue(minutes_since_last_access=11) + self.snapshot.refresh() + entry = self.read()[0] + self.assertFalse(entry["online"]) + self.assertIn("last_seen", entry) + + def test_snapshot_is_only_rewritten_when_it_changes(self): + self.issue() + self.snapshot.refresh() + # Nothing changed, so a refresh must not touch the file + self.snapshot_path.write_text("left untouched") + self.snapshot.refresh() + self.assertEqual(self.snapshot_path.read_text(), "left untouched") + + self.issue() + self.snapshot.refresh() + self.assertEqual(len(self.read()), 2) + + def test_expired_revoked_and_outdated_sessions_are_removed(self): + expired = self.service.issue_session(username="alice", add_factors=["password"], expires_in_minutes=1, + metadata={"credential": credential_fingerprint(ALICE)}) + expired.expires_at = datetime.now(UTC) - timedelta(minutes=1) + self.storage.save_session(expired) + revoked = self.issue() + outdated = self.service.issue_session(username="alice", add_factors=["password"], metadata={"credential": "old"}) + kept = self.issue() + write_config(self.config_dir, {"alice": ALICE.model_dump()}, revoked=[session_id_hash(revoked.session_id)]) + + self.snapshot.refresh() + self.assertEqual([entry["id"] for entry in self.read()], [session_id_hash(kept.session_id)]) + for removed in (expired, revoked, outdated): + self.assertIsNone(self.storage.get_session(removed.session_id)) + + +if __name__ == "__main__": + unittest.main() diff --git a/containers/cluster_node/cluster_worker.py b/containers/cluster_node/cluster_worker.py index aebe4b4..9a8adf9 100644 --- a/containers/cluster_node/cluster_worker.py +++ b/containers/cluster_node/cluster_worker.py @@ -1,4 +1,5 @@ import glob +import hashlib import ipaddress import json import logging @@ -18,7 +19,7 @@ logger = logging.getLogger(__name__) MASTER_SERVER_ADDRESS = os.environ.get('MASTER_SERVER_ADDRESS', '') TOKEN = os.environ.get('TOKEN', '') -WORKER_VERSION = 13 +WORKER_VERSION = 14 REQUEST_TIMEOUT = 30 MANIFEST_INTERVAL = 60 DEFAULT_STATS_INTERVAL = 60 @@ -31,6 +32,10 @@ DNS_MAIN_CONFIG = 'wireguard_webadmin_dns.conf' GATEWAY_DIR = '/caddy_json_export' CERTIFICATES_DIR = '/caddy_certificates' GATEWAY_FILES = ('applications.json', 'auth_policies.json', 'routes.json', 'tls.json') +# Sessions ended from the WireGuard WebAdmin, sent by primary servers that support it +GATEWAY_OPTIONAL_FILES = ('revoked_sessions.json',) +# Active sessions published by the auth-gateway +GATEWAY_SESSIONS_FILE = os.path.join(GATEWAY_DIR, 'state', 'sessions.json') CERTIFICATE_FILE_PATTERN = re.compile(r'^[a-f0-9]{64}\.(crt|key)$') CADDY_ADMIN_URL = 'http://127.0.0.1:2019/config/' AUTH_GATEWAY_URL = 'http://cluster-node-auth-gateway:9091/' @@ -238,6 +243,8 @@ class ClusterNodeAgent: self.applied_hashes = {} self.stats_interval = DEFAULT_STATS_INTERVAL self.wireguard_active = False + # Hash of the last gateway sessions accepted by the primary server: they are only sent when they change + self.sent_sessions_hash = None def request(self, method, path, **kwargs): try: @@ -347,8 +354,9 @@ class ClusterNodeAgent: for filename in GATEWAY_FILES: if filename not in section['files']: raise SectionError(f'{filename} missing from section') - for filename in GATEWAY_FILES: - write_file(os.path.join(GATEWAY_DIR, filename), section['files'][filename], mode=0o644) + for filename in GATEWAY_FILES + GATEWAY_OPTIONAL_FILES: + if filename in section['files']: + write_file(os.path.join(GATEWAY_DIR, filename), section['files'][filename], mode=0o644) SECTION_HANDLERS = { 'firewall': apply_firewall, @@ -432,14 +440,34 @@ class ClusterNodeAgent: return {} return {hostname: inspect_certificate(hostname) for hostname in sorted(hosts)} + @staticmethod + def gateway_sessions(): + """Sessions published by the auth-gateway and their hash, or (None, None) when not available.""" + content = read_file(GATEWAY_SESSIONS_FILE) + if content is None: + return None, None + try: + sessions = json.loads(content).get('sessions') + except (ValueError, AttributeError): + return None, None + if not isinstance(sessions, list): + return None, None + return sessions, hashlib.sha256(content.encode()).hexdigest() + def send_stats(self): report = { 'wireguard_status': wireguard_status(), 'services': self.services_status(), } + sessions_hash = None if gateway_enabled(): report['certificates'] = self.certificates_status() - self.request('POST', 'report/', json=report) + sessions, sessions_hash = self.gateway_sessions() + if sessions_hash and sessions_hash != self.sent_sessions_hash: + report['gateway_sessions'] = sessions + response = self.request('POST', 'report/', json=report) + if 'gateway_sessions' in report and response is not None and response.status_code == 200: + self.sent_sessions_hash = sessions_hash @staticmethod def publish_network_namespace(): diff --git a/gatekeeper/migrations/0012_revokedgatewaysession.py b/gatekeeper/migrations/0012_revokedgatewaysession.py new file mode 100644 index 0000000..f4b1da4 --- /dev/null +++ b/gatekeeper/migrations/0012_revokedgatewaysession.py @@ -0,0 +1,26 @@ +# Generated by Django 5.2.19 on 2026-11-21 18:56 + +import uuid + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('gatekeeper', '0011_authmethod_display_name_gatekeepergroup_display_name'), + ] + + operations = [ + migrations.CreateModel( + name='RevokedGatewaySession', + fields=[ + ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('session_hash', models.CharField(max_length=64, unique=True)), + ('username', models.CharField(blank=True, max_length=254)), + ('expires_at', models.DateTimeField()), + ('created', models.DateTimeField(auto_now_add=True)), + ('uuid', models.UUIDField(default=uuid.uuid4, editable=False, unique=True)), + ], + ), + ] diff --git a/gatekeeper/models.py b/gatekeeper/models.py index ca26423..859ea3f 100644 --- a/gatekeeper/models.py +++ b/gatekeeper/models.py @@ -154,4 +154,17 @@ class GatekeeperIPAddress(models.Model): ordering = ['address'] unique_together = [('auth_method', 'address', 'prefix_length')] verbose_name = 'IP Address' - verbose_name_plural = 'IP Addresses' \ No newline at end of file + verbose_name_plural = 'IP Addresses' + + +class RevokedGatewaySession(models.Model): + """Session ended from the WireGuard WebAdmin. Kept until the session would have expired.""" + session_hash = models.CharField(max_length=64, unique=True) + username = models.CharField(max_length=254, blank=True) + expires_at = models.DateTimeField() + + created = models.DateTimeField(auto_now_add=True) + uuid = models.UUIDField(unique=True, default=uuid.uuid4, editable=False) + + def __str__(self): + return f'{self.username or "-"} ({self.session_hash[:12]})' diff --git a/gatekeeper/sessions.py b/gatekeeper/sessions.py new file mode 100644 index 0000000..02593e4 --- /dev/null +++ b/gatekeeper/sessions.py @@ -0,0 +1,126 @@ +"""Sessions of the auth-gateway: published by each gateway, listed and revoked from the WireGuard WebAdmin.""" +import ipaddress +import json +import os +import re + +from django.utils import timezone +from django.utils.dateparse import parse_datetime + +from app_gateway.caddy_config_export import CADDY_EXPORT_DIR +from cluster.models import Worker +from gatekeeper.models import RevokedGatewaySession + +PRIMARY_SESSIONS_FILE = os.path.join('state', 'sessions.json') +REVOKED_SESSIONS_FILE = 'revoked_sessions.json' +MAX_REPORTED_SESSIONS = 5000 +SESSION_ID_PATTERN = re.compile(r'^[a-f0-9]{64}$') +TEXT_FIELDS = ('username', 'email', 'host', 'client_ip', 'user_agent', 'created_at', 'expires_at', 'last_seen') +LIST_FIELDS = ('groups', 'factors') + + +def get_export_dir(): + return CADDY_EXPORT_DIR + + +def clean_gateway_sessions(sessions): + """Keep only the known fields of the sessions published by a gateway.""" + cleaned = [] + for session in sessions[:MAX_REPORTED_SESSIONS]: + if not isinstance(session, dict) or not SESSION_ID_PATTERN.match(str(session.get('id', ''))): + continue + entry = {'id': session['id'], 'online': session.get('online') is True} + for field in TEXT_FIELDS: + if isinstance(session.get(field), str): + entry[field] = session[field][:254] + for field in LIST_FIELDS: + values = session.get(field) + entry[field] = [str(value)[:64] for value in values[:50]] if isinstance(values, list) else [] + cleaned.append(entry) + return cleaned + + +def load_primary_sessions(export_dir=None): + """Sessions published by the auth-gateway of this primary server, or None when it published none.""" + try: + with open(os.path.join(export_dir or get_export_dir(), PRIMARY_SESSIONS_FILE), 'r', encoding='utf-8') as sessions_file: + sessions = json.load(sessions_file).get('sessions') + except (OSError, ValueError, AttributeError): + return None + return clean_gateway_sessions(sessions) if isinstance(sessions, list) else None + + +def ip_sort_key(value): + """Value that sorts IP addresses numerically in the sessions table (IPv4, then IPv6, then anything else).""" + try: + address = ipaddress.ip_address(value) + except ValueError: + return f'9-{value}' + return f'{address.version - 4}-{int(address):039d}' + + +def _describe(session, server_name, server_key, stale, reported_at, revoked_hashes): + return dict( + session, + server_name=server_name, + server_key=server_key, + stale=stale, + reported_at=reported_at, + revoking=session['id'] in revoked_hashes, + created=parse_datetime(session.get('created_at', '')), + expires=parse_datetime(session.get('expires_at', '')), + last_seen_at=parse_datetime(session.get('last_seen', '')) if session.get('last_seen') else None, + client_ip_order=ip_sort_key(session.get('client_ip', '')), + ) + + +def get_active_sessions(export_dir=None): + """Sessions of the primary server and of every worker. Worker sessions are the last ones it reported.""" + revoked_hashes = set(RevokedGatewaySession.objects.filter(expires_at__gt=timezone.now()).values_list('session_hash', flat=True)) + rows = [ + _describe(session, None, 'primary', False, None, revoked_hashes) + for session in load_primary_sessions(export_dir) or [] + ] + for worker in Worker.objects.select_related('workerstatus').order_by('name'): + worker_status = getattr(worker, 'workerstatus', None) + if not worker_status or not worker_status.gateway_sessions: + continue + stale = not worker.enabled or not worker_status.is_online + for session in worker_status.gateway_sessions: + rows.append(_describe( + session, worker.display_name, str(worker.uuid), stale, worker_status.gateway_sessions_updated, revoked_hashes, + )) + rows.sort(key=lambda row: (not row['online'], row.get('username') or row.get('email') or '', row['server_key'])) + return rows + + +def build_revoked_sessions_data(): + hashes = RevokedGatewaySession.objects.filter(expires_at__gt=timezone.now()).values_list('session_hash', flat=True) + return {'sessions': sorted(hashes)} + + +def write_revoked_sessions(export_dir=None): + """Publish the revoked sessions to the auth-gateway of this primary server (workers get them by the cluster).""" + RevokedGatewaySession.objects.filter(expires_at__lte=timezone.now()).delete() + export_dir = export_dir or get_export_dir() + if not os.path.isdir(export_dir): + return + target = os.path.join(export_dir, REVOKED_SESSIONS_FILE) + temp_path = f'{target}.tmp' + with open(temp_path, 'w', encoding='utf-8') as revoked_file: + json.dump(build_revoked_sessions_data(), revoked_file, indent=2) + revoked_file.write('\n') + os.replace(temp_path, target) + + +def revoke_session(session_hash, export_dir=None): + """End a session listed by get_active_sessions. Return the revoked session, or None when it is not listed.""" + session = next((row for row in get_active_sessions(export_dir) if row['id'] == session_hash), None) + if not session or not session['expires']: + return None + RevokedGatewaySession.objects.update_or_create( + session_hash=session_hash, + defaults={'username': session.get('username') or session.get('email') or '', 'expires_at': session['expires']}, + ) + write_revoked_sessions(export_dir) + return session diff --git a/gatekeeper/tests.py b/gatekeeper/tests.py index a39b155..0c8aa35 100644 --- a/gatekeeper/tests.py +++ b/gatekeeper/tests.py @@ -1 +1,141 @@ -# Create your tests here. +import json +import os +import tempfile +from datetime import timedelta +from unittest.mock import patch + +from django.contrib.auth.models import User +from django.test import TestCase +from django.utils import timezone + +from cluster.models import Worker, WorkerStatus +from cluster.sync import build_gateway_section +from gatekeeper.models import RevokedGatewaySession +from gatekeeper.sessions import ( + REVOKED_SESSIONS_FILE, + build_revoked_sessions_data, + clean_gateway_sessions, + get_active_sessions, +) +from user_manager.models import UserAcl + +PRIMARY_ID = 'a' * 64 +WORKER_ID = 'b' * 64 + + +def gateway_session(session_id, username='alice', online=True, expires_in_hours=6): + session = { + 'id': session_id, + 'username': username, + 'email': f'{username}@example.test', + 'groups': ['staff'], + 'factors': ['password'], + 'host': 'app.example.test', + 'client_ip': '203.0.113.5', + 'user_agent': 'test', + 'created_at': timezone.now().isoformat(), + 'expires_at': (timezone.now() + timedelta(hours=expires_in_hours)).isoformat(), + 'online': online, + } + if not online: + session['last_seen'] = (timezone.now() - timedelta(minutes=30)).isoformat() + return session + + +class GatewaySessionsTestMixin: + """Primary server sessions in a temporary export directory and one worker reporting its sessions.""" + + def setUp(self): + super().setUp() + temp_dir = tempfile.TemporaryDirectory() + self.addCleanup(temp_dir.cleanup) + self.export_dir = temp_dir.name + patcher = patch('gatekeeper.sessions.CADDY_EXPORT_DIR', self.export_dir) + patcher.start() + self.addCleanup(patcher.stop) + + os.makedirs(os.path.join(self.export_dir, 'state')) + with open(os.path.join(self.export_dir, 'state', 'sessions.json'), 'w', encoding='utf-8') as sessions_file: + json.dump({'sessions': [gateway_session(PRIMARY_ID)]}, sessions_file) + + self.worker = Worker.objects.create(name='node-a', hostname='node-a.example.test') + WorkerStatus.objects.create( + worker=self.worker, gateway_sessions=[gateway_session(WORKER_ID, username='bob', online=False)], + gateway_sessions_updated=timezone.now(), + ) + + def read_revoked_file(self): + with open(os.path.join(self.export_dir, REVOKED_SESSIONS_FILE), 'r', encoding='utf-8') as revoked_file: + return json.load(revoked_file)['sessions'] + + +class GatewaySessionDataTests(GatewaySessionsTestMixin, TestCase): + def test_reported_sessions_keep_only_known_fields(self): + cleaned = clean_gateway_sessions([ + dict(gateway_session(PRIMARY_ID), session_id='secret', extra='x', groups=['g'] * 80), + {'id': 'not-a-hash', 'username': 'mallory'}, + 'not a session', + ]) + self.assertEqual(len(cleaned), 1) + self.assertNotIn('session_id', cleaned[0]) + self.assertNotIn('extra', cleaned[0]) + self.assertEqual(len(cleaned[0]['groups']), 50) + + def test_active_sessions_list_primary_and_workers(self): + sessions = {session['id']: session for session in get_active_sessions()} + self.assertEqual(set(sessions), {PRIMARY_ID, WORKER_ID}) + self.assertIsNone(sessions[PRIMARY_ID]['server_name']) + self.assertEqual(sessions[WORKER_ID]['server_name'], self.worker.display_name) + self.assertFalse(sessions[WORKER_ID]['online']) + self.assertIsNotNone(sessions[WORKER_ID]['last_seen_at']) + + def test_sessions_of_offline_workers_are_marked(self): + WorkerStatus.objects.filter(worker=self.worker).update(last_seen=timezone.now() - timedelta(minutes=20)) + sessions = {session['id']: session for session in get_active_sessions()} + self.assertTrue(sessions[WORKER_ID]['stale']) + self.assertFalse(sessions[PRIMARY_ID]['stale']) + + def test_revoked_sessions_only_list_sessions_not_expired(self): + RevokedGatewaySession.objects.create(session_hash=PRIMARY_ID, expires_at=timezone.now() + timedelta(hours=1)) + RevokedGatewaySession.objects.create(session_hash=WORKER_ID, expires_at=timezone.now() - timedelta(hours=1)) + self.assertEqual(build_revoked_sessions_data(), {'sessions': [PRIMARY_ID]}) + + def test_gateway_section_carries_revoked_sessions_to_workers(self): + RevokedGatewaySession.objects.create(session_hash=WORKER_ID, expires_at=timezone.now() + timedelta(hours=1)) + section = build_gateway_section(self.worker) + self.assertEqual(json.loads(section.files[REVOKED_SESSIONS_FILE])['sessions'], [WORKER_ID]) + + +class RevokeSessionViewTests(GatewaySessionsTestMixin, TestCase): + def setUp(self): + super().setUp() + self.admin = User.objects.create_user(username='admin', password='unused') + UserAcl.objects.create(user=self.admin, user_level=50) + self.client.force_login(self.admin) + + def test_revoking_a_worker_session_publishes_it(self): + response = self.client.post('/gatekeeper/session/revoke/', {'session': WORKER_ID}) + self.assertRedirects(response, '/gatekeeper/?tab=sessions', fetch_redirect_response=False) + revoked = RevokedGatewaySession.objects.get(session_hash=WORKER_ID) + self.assertEqual(revoked.username, 'bob') + self.assertEqual(self.read_revoked_file(), [WORKER_ID]) + self.assertTrue(next(session for session in get_active_sessions() if session['id'] == WORKER_ID)['revoking']) + + def test_unknown_session_is_not_revoked(self): + self.client.post('/gatekeeper/session/revoke/', {'session': 'c' * 64}) + self.assertFalse(RevokedGatewaySession.objects.exists()) + + def test_revoke_requires_post(self): + self.assertEqual(self.client.get('/gatekeeper/session/revoke/', {'session': WORKER_ID}).status_code, 405) + self.assertFalse(RevokedGatewaySession.objects.exists()) + + def test_revoke_requires_level_50(self): + UserAcl.objects.filter(user=self.admin).update(user_level=40) + self.client.post('/gatekeeper/session/revoke/', {'session': WORKER_ID}) + self.assertFalse(RevokedGatewaySession.objects.exists()) + + def test_sessions_tab_lists_sessions(self): + UserAcl.objects.filter(user=self.admin).update(user_level=20) + content = self.client.get('/gatekeeper/?tab=sessions').content.decode() + self.assertIn('alice@example.test', content) + self.assertIn('bob@example.test', content) diff --git a/gatekeeper/urls.py b/gatekeeper/urls.py index b762dd6..d02e3f8 100644 --- a/gatekeeper/urls.py +++ b/gatekeeper/urls.py @@ -30,4 +30,7 @@ urlpatterns = [ # Gatekeeper IP Addresses path('ip/manage/', views.view_manage_gatekeeper_ip, name='manage_gatekeeper_ip'), path('ip/delete/', views.view_delete_gatekeeper_ip, name='delete_gatekeeper_ip'), + + # Gateway sessions + path('session/revoke/', views.view_revoke_gatekeeper_session, name='revoke_gatekeeper_session'), ] diff --git a/gatekeeper/views.py b/gatekeeper/views.py index dcd0c26..c47f376 100644 --- a/gatekeeper/views.py +++ b/gatekeeper/views.py @@ -9,6 +9,7 @@ from django.http import HttpResponse from django.shortcuts import render, get_object_or_404, redirect from django.urls import reverse from django.utils.translation import gettext as _ +from django.views.decorators.http import require_POST from app_gateway.caddy_config_export import auto_apply_caddy_config, caddy_export_pending from app_gateway.setup_defaults import create_default_entries @@ -16,6 +17,7 @@ from gatekeeper.forms import GatekeeperUserForm, GatekeeperGroupForm, AuthMethod AuthMethodAllowedEmailForm, GatekeeperIPAddressForm from gatekeeper.models import GatekeeperUser, GatekeeperGroup, AuthMethod, AuthMethodAllowedDomain, \ AuthMethodAllowedEmail, GatekeeperIPAddress +from gatekeeper.sessions import get_active_sessions, revoke_session from user_manager.models import UserAcl @@ -44,10 +46,27 @@ def view_gatekeeper_list(request): 'active_tab': active_tab, 'caddy_enabled': settings.CADDY_ENABLED, 'pending_export': caddy_export_pending(), + 'gateway_sessions': get_active_sessions() if active_tab == 'sessions' else [], } return render(request, 'gatekeeper/gatekeeper_list.html', context) +@login_required +@require_POST +def view_revoke_gatekeeper_session(request): + if not UserAcl.objects.filter(user=request.user).filter(user_level__gte=50).exists(): + return render(request, 'access_denied.html', {'page_title': _('Access Denied')}) + + session = revoke_session(request.POST.get('session', '')) + if session: + messages.success(request, _('Session ended|The session of %(user)s ends on its server within a minute.') % { + 'user': session.get('username') or session.get('email') or '-' + }) + else: + messages.warning(request, _('Session not found|The session is no longer active.')) + return redirect(reverse('gatekeeper_list') + '?tab=sessions') + + @login_required def view_manage_gatekeeper_user(request): if not UserAcl.objects.filter(user=request.user).filter(user_level__gte=50).exists(): diff --git a/templates/gatekeeper/gatekeeper_list.html b/templates/gatekeeper/gatekeeper_list.html index 5984644..8acba1d 100644 --- a/templates/gatekeeper/gatekeeper_list.html +++ b/templates/gatekeeper/gatekeeper_list.html @@ -1,5 +1,22 @@ {% extends "base.html" %} -{% load i18n %} +{% load i18n static %} + +{% block page_custom_head %} +{% if active_tab == 'sessions' and gateway_sessions %} + + + +{% endif %} +{% endblock %} {% block content %} {% include 'app_gateway/caddy_disabled_alert.html' %} @@ -32,6 +49,12 @@ {% trans 'IP Addresses' %} +
+ {% trans 'Sessions opened on the App Gateway login. A session is online when it was used in the last 10 minutes. Sessions of cluster workers are the last ones each worker reported.' %} +
+ {% if gateway_sessions %} +| {% trans 'User' %} | +{% trans 'Server' %} | +{% trans 'Host' %} | +{% trans 'Last access' %} | +{% trans 'IP Address' %} | +{% trans 'Factors' %} | +{% trans 'Started' %} | +{% trans 'Expires' %} | +{% trans 'Browser' %} | +{% trans 'Manage' %} | +
|---|---|---|---|---|---|---|---|---|---|
|
+ {{ session.username|default:session.email|default:'-' }}
+ {% if session.username and session.email %} {{ session.email }}{% endif %} + |
+
+ {{ session.server_name|default:_('Primary Server') }}
+ {% if session.stale %} {% trans 'Worker offline' %}{% endif %} + |
+ {{ session.host|default:'-' }} | ++ {% if session.online %} + {% trans 'Online' %} + {% else %} + {{ session.last_seen_at|date:'SHORT_DATETIME_FORMAT'|default:'-' }} + {% endif %} + | +{{ session.client_ip|default:'-' }} | +{{ session.factors|join:', '|default:'-' }} | +{{ session.created|date:'SHORT_DATETIME_FORMAT' }} | +{{ session.expires|date:'SHORT_DATETIME_FORMAT' }} | +{{ session.user_agent|truncatechars:60|default:'-' }} | ++ {% if session.revoking %} + {% trans 'Ending' %} + {% else %} + + {% endif %} + | +