mirror of
https://github.com/eduardogsilva/wireguard_webadmin.git
synced 2026-11-22 04:43:18 +01:00
Add gateway sessions page and end sessions on credential change
This commit is contained in:
@@ -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),
|
||||
),
|
||||
]
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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()
|
||||
@@ -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,7 +354,8 @@ 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:
|
||||
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 = {
|
||||
@@ -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)),
|
||||
],
|
||||
),
|
||||
]
|
||||
@@ -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]})'
|
||||
|
||||
@@ -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
@@ -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)
|
||||
|
||||
@@ -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'),
|
||||
]
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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 %}
|
||||
|
||||
@@ -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"
|
||||
|
||||
Reference in New Issue
Block a user