Add gateway sessions page and end sessions on credential change

This commit is contained in:
Eduardo Silva
2026-11-21 16:43:06 -03:00
parent 7fd1a4fbc3
commit bf71df194d
24 changed files with 957 additions and 13 deletions
+6
View File
@@ -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()
@@ -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),
),
]
+3
View File
@@ -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)
+3
View File
@@ -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
+90
View File
@@ -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": []}')
@@ -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():
@@ -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(
@@ -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)
@@ -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)
@@ -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
@@ -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,))
@@ -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:
@@ -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:
@@ -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)
@@ -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()
+32 -4
View File
@@ -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():
@@ -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)),
],
),
]
+13
View File
@@ -155,3 +155,16 @@ class GatekeeperIPAddress(models.Model):
unique_together = [('auth_method', 'address', 'prefix_length')]
verbose_name = 'IP Address'
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]})'
+126
View File
@@ -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
+141 -1
View File
@@ -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)
+3
View File
@@ -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'),
]
+19
View File
@@ -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():
+135 -1
View File
@@ -1,5 +1,22 @@
{% extends "base.html" %}
{% load i18n %}
{% load i18n static %}
{% block page_custom_head %}
{% if active_tab == 'sessions' and gateway_sessions %}
<link rel="stylesheet" href="{% static 'AdminLTE-3.2.0/plugins/datatables-bs4/css/dataTables.bootstrap4.min.css' %}">
<link rel="stylesheet" href="{% static 'AdminLTE-3.2.0/plugins/datatables-buttons/css/buttons.bootstrap4.min.css' %}">
<style>
/* The column menu of DataTables Buttons has no dark mode of its own */
.dark-mode div.dt-button-collection {
background-color: #343a40;
border-color: #6c757d;
}
.dark-mode div.dt-button-collection .dropdown-item:not(.active):hover {
background-color: #495057;
}
</style>
{% endif %}
{% endblock %}
{% block content %}
{% include 'app_gateway/caddy_disabled_alert.html' %}
@@ -32,6 +49,12 @@
{% trans 'IP Addresses' %}
</a>
</li>
<li class="nav-item">
<a class="nav-link {% if active_tab == 'sessions' %}active{% endif %}"
href="{% url 'gatekeeper_list' %}?tab=sessions" role="tab">
{% trans 'Sessions' %}
</a>
</li>
</ul>
<div class="tab-content mt-4">
@@ -312,9 +335,120 @@
</div>
{% endif %}
{% elif active_tab == 'sessions' %}
<p class="text-muted">
{% 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.' %}
</p>
{% if gateway_sessions %}
<table id="gateway-sessions-table" class="table table-striped table-hover w-100">
<thead>
<tr>
<th>{% trans 'User' %}</th>
<th>{% trans 'Server' %}</th>
<th>{% trans 'Host' %}</th>
<th>{% trans 'Last access' %}</th>
<th>{% trans 'IP Address' %}</th>
<th>{% trans 'Factors' %}</th>
<th>{% trans 'Started' %}</th>
<th>{% trans 'Expires' %}</th>
<th>{% trans 'Browser' %}</th>
<th class="no-colvis">{% trans 'Manage' %}</th>
</tr>
</thead>
<tbody>
{% for session in gateway_sessions %}
<tr>
<td data-order="{{ session.username|default:session.email|lower }}">
{{ session.username|default:session.email|default:'-' }}
{% if session.username and session.email %}<br><small class="text-muted">{{ session.email }}</small>{% endif %}
</td>
<td data-order="{{ session.server_name|default:'' }}">
{{ session.server_name|default:_('Primary Server') }}
{% if session.stale %}<br><span class="badge badge-secondary" title="{% trans 'Last report' %}: {{ session.reported_at|date:'SHORT_DATETIME_FORMAT' }}">{% trans 'Worker offline' %}</span>{% endif %}
</td>
<td>{{ session.host|default:'-' }}</td>
<td data-order="{% if session.online %}9999-12-31{% else %}{{ session.last_seen|default:'' }}{% endif %}">
{% if session.online %}
<span class="badge badge-success">{% trans 'Online' %}</span>
{% else %}
{{ session.last_seen_at|date:'SHORT_DATETIME_FORMAT'|default:'-' }}
{% endif %}
</td>
<td data-order="{{ session.client_ip_order }}">{{ session.client_ip|default:'-' }}</td>
<td>{{ session.factors|join:', '|default:'-' }}</td>
<td data-order="{{ session.created_at|default:'' }}">{{ session.created|date:'SHORT_DATETIME_FORMAT' }}</td>
<td data-order="{{ session.expires_at|default:'' }}">{{ session.expires|date:'SHORT_DATETIME_FORMAT' }}</td>
<td><small title="{{ session.user_agent }}">{{ session.user_agent|truncatechars:60|default:'-' }}</small></td>
<td class="text-nowrap">
{% if session.revoking %}
<span class="badge badge-warning">{% trans 'Ending' %}</span>
{% else %}
<form method="post" action="{% url 'revoke_gatekeeper_session' %}" class="d-inline">
{% csrf_token %}
<input type="hidden" name="session" value="{{ session.id }}">
<button type="submit" class="btn btn-sm btn-danger" title="{% trans 'End session' %}">
<i class="fas fa-sign-out-alt"></i>
</button>
</form>
{% endif %}
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% else %}
<div class="alert alert-info">
{% trans 'No active sessions.' %}
</div>
{% endif %}
{% endif %}
</div>
</div>
</div>
{% endblock %}
{% block custom_page_scripts %}
{% if active_tab == 'sessions' and gateway_sessions %}
<script src="{% static 'AdminLTE-3.2.0/plugins/datatables/jquery.dataTables.min.js' %}"></script>
<script src="{% static 'AdminLTE-3.2.0/plugins/datatables-bs4/js/dataTables.bootstrap4.min.js' %}"></script>
<script src="{% static 'AdminLTE-3.2.0/plugins/datatables-buttons/js/dataTables.buttons.min.js' %}"></script>
<script src="{% static 'AdminLTE-3.2.0/plugins/datatables-buttons/js/buttons.bootstrap4.min.js' %}"></script>
<script src="{% static 'AdminLTE-3.2.0/plugins/datatables-buttons/js/buttons.colVis.min.js' %}"></script>
<script>
$(function () {
$('#gateway-sessions-table').DataTable({
// Visible columns and sorting chosen by the user are kept in this browser
stateSave: true,
stateDuration: 0,
stateSaveParams: function (settings, data) {
data.search.search = '';
data.start = 0;
},
order: [[3, 'desc'], [0, 'asc']],
pageLength: 25,
autoWidth: false,
columnDefs: [
{targets: [4, 5, 6, 7, 8], visible: false},
{targets: 9, orderable: false, searchable: false},
],
dom: "<'row'<'col-sm-12 col-md-6'B><'col-sm-12 col-md-6'f>>" +
"<'row'<'col-sm-12 table-responsive'tr>>" +
"<'row'<'col-sm-12 col-md-5'i><'col-sm-12 col-md-7'p>>",
buttons: [
{extend: 'colvis', text: '<i class="fas fa-columns"></i> {% trans "Columns"|escapejs %}', columns: ':not(.no-colvis)'},
],
language: {
search: '{% trans "Search:"|escapejs %}',
info: '{% trans "Showing _START_ to _END_ of _TOTAL_ sessions"|escapejs %}',
infoEmpty: '{% trans "No sessions to show"|escapejs %}',
infoFiltered: '{% trans "(filtered from _MAX_ sessions)"|escapejs %}',
zeroRecords: '{% trans "No matching sessions"|escapejs %}',
paginate: {previous: '{% trans "Previous"|escapejs %}', next: '{% trans "Next"|escapejs %}'},
},
});
});
</script>
{% endif %}
{% endblock %}
+1 -1
View File
@@ -176,7 +176,7 @@ DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
WIREGUARD_WEBADMIN_VERSION = 9982
CLUSTER_WORKER_CURRENT_VERSION = 13
CLUSTER_WORKER_CURRENT_VERSION = 14
CLUSTER_WORKER_MINIMUM_VERSION = 12
CADDY_ENABLED = os.getenv("CADDY_ENABLED", "false").lower() == "true"