ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
fix(auth): enforce MFA, scoped keys, and revocable sessions
Juan Denisc8c93a8e0c7b
diff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex eef51398..07cc6fa2 100644--- a/backend/app/__init__.py+++ b/backend/app/__init__.py@@ -20,6 +20,26 @@ migrate = Migrate()@jwt.user_identity_loaderdef _user_identity(user_id):return str(user_id)++[email protected]_claims_loader+def _session_claims(user_id):+ import time+ import secrets+ from app.models import User+ user = db.session.get(User, user_id)+ session_id = secrets.token_hex(16)+ return {'auth_version': user.auth_version if user else None,+ 'session_id': session_id,+ 'auth_time': int(time.time())}++[email protected]_in_blocklist_loader+def _session_revoked(_header, claims):+ from app.middleware.session_auth import validate_session_claims+ return validate_session_claims(claims, token_type=claims.get('type')) is None++limiter = Limiter(key_func=get_remote_address, default_limits=["100 per minute"])# Note: key_func is updated to get_rate_limit_key after app initsocketio = None@@ -451,25 +471,9 @@ def create_app(config_name=None):# Request body size limitapp.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024 # 100MB limit- # Reject 2FA pending tokens on non-2FA endpoints- @app.before_request- def check_2fa_pending():- """Reject 2FA pending tokens on non-2FA endpoints."""- from flask_jwt_extended import verify_jwt_in_request, get_jwt- if request.endpoint and request.path.startswith('/api/'):- # Allow 2FA verification endpoints- if '/two-factor/verify' in request.path or '/two-factor/verify-backup' in request.path:- return- # Allow auth endpoints (login, refresh)- if '/auth/login' in request.path or '/auth/refresh' in request.path:- return- try:- verify_jwt_in_request()- claims = get_jwt()- if claims.get('2fa_pending'):- return jsonify({'error': '2FA verification required'}), 403- except Exception:- pass # Let @jwt_required handle actual auth errors+ # JWTManager's blocklist callback enforces session validity for every JWT+ # route. MFA verification alone decodes its body token explicitly, so no+ # path-prefix exceptions can turn a pending token into a full session.# Serve frontend for root path@app.route('/')diff --git a/backend/app/api/auth.py b/backend/app/api/auth.pyindex b3120599..975c78c9 100644--- a/backend/app/api/auth.py+++ b/backend/app/api/auth.py@@ -1,10 +1,9 @@import logging-from datetime import datetime-from flask import Blueprint, request, jsonify+from datetime import datetime, timedelta+from flask import Blueprint, request, jsonify, gfrom sqlalchemy import funcfrom flask_jwt_extended import (create_access_token,- create_refresh_token,jwt_required,get_jwt_identity,get_jwt@@ -13,6 +12,7 @@ from app import db, limiterfrom app.models import User, AuditLog, SystemSettings# Aliased: this module already has a `get_current_user` route handler.from app.middleware.rbac import admin_required, get_current_user as get_request_user, require_admin_user+from app.middleware.session_auth import session_required, issue_session_tokensfrom app.services.settings_service import SettingsServicefrom app.services.audit_service import AuditServicefrom app.services import login_link_service@@ -154,8 +154,7 @@ def register():)db.session.commit()- access_token = create_access_token(identity=user.id)- refresh_token = create_refresh_token(identity=user.id)+ access_token, refresh_token = issue_session_tokens(user.id)return jsonify({'message': 'User registered successfully',@@ -291,7 +290,7 @@ def login():temp_token = create_access_token(identity=user.id,additional_claims={'2fa_pending': True},- expires_delta=False # Use default (short) expiry+ expires_delta=timedelta(minutes=5))return jsonify({@@ -309,8 +308,7 @@ def login():AuditService.log_login(user.id, success=True)db.session.commit()- access_token = create_access_token(identity=user.id)- refresh_token = create_refresh_token(identity=user.id)+ access_token, refresh_token = issue_session_tokens(user.id)return jsonify({'user': user.to_dict(),@@ -323,10 +321,10 @@ def login():# ONE-TIME LOGIN LINKS# ==========================================@auth_bp.route('/login-links', methods=['POST'])-@admin_required+@session_requireddef create_login_link():"""Mint a single-use login URL. The raw token is returned exactly once."""- current = get_request_user()+ current = require_admin_user()data = request.get_json() or {}target_id = data.get('user_id') or current.id@@ -413,6 +411,14 @@ def redeem_login_link():raise AuthenticationError('Invalid or expired link', code='auth.link_invalid')auth_throttle_service.reset(client_ip)+ if user.totp_enabled:+ return jsonify({+ 'requires_2fa': True,+ 'temp_token': create_access_token(+ identity=user.id, additional_claims={'2fa_pending': True},+ expires_delta=timedelta(minutes=5)),+ 'message': 'Two-factor authentication required',+ }), 200user.reset_failed_login()user.last_login_at = datetime.utcnow()db.session.commit()@@ -420,8 +426,7 @@ def redeem_login_link():AuditService.log_login(user.id, success=True, details={'method': 'login_link'})db.session.commit()- access_token = create_access_token(identity=user.id)- refresh_token = create_refresh_token(identity=user.id)+ access_token, refresh_token = issue_session_tokens(user.id)return jsonify({'user': user.to_dict(),@@ -481,13 +486,27 @@ def refresh():if not user or not user.is_active:return jsonify({'error': 'Invalid user'}), 401- access_token = create_access_token(identity=current_user_id)+ access_token = create_access_token(+ identity=current_user_id,+ additional_claims={'auth_time': get_jwt().get('auth_time', 0),+ 'session_id': get_jwt()['session_id']})return jsonify({'access_token': access_token}), 200+@auth_bp.route('/logout', methods=['POST'])+@session_required+def logout():+ """Revoke this browser's access and refresh session, across workers."""+ from app.models import RevokedSession+ db.session.add(RevokedSession(session_id=get_jwt()['session_id'],+ user_id=g.session_user.id))+ db.session.commit()+ return jsonify({'message': 'Browser session signed out'}), 200++@auth_bp.route('/me', methods=['GET'])@jwt_required()def get_current_user():@@ -527,7 +546,23 @@ def update_current_user():if not user:return jsonify({'error': 'User not found'}), 404- data = request.get_json()+ data = request.get_json() or {}++ if 'password' in data:+ import time+ if not isinstance(data['password'], str) or len(data['password']) < 8:+ raise ValidationError('Password must be at least 8 characters')+ if user.has_password:+ current_password = data.get('current_password')+ if (not isinstance(current_password, str)+ or not user.check_password(current_password)):+ raise PermissionDeniedError('Current password is required and must be correct')+ else:+ # SSO/passkey users without a local password must have completed a+ # fresh sign-in. Refresh preserves auth_time and cannot renew it.+ auth_time = get_jwt().get('auth_time', 0)+ if not isinstance(auth_time, (int, float)) or time.time() - auth_time > 300:+ raise PermissionDeniedError('Sign in again before setting a password')if 'username' in data:existing = User.query.filter_by(username=data['username']).first()@@ -544,8 +579,6 @@ def update_current_user():user.email = data['email']if 'password' in data:- if len(data['password']) < 8:- return jsonify({'error': 'Password must be at least 8 characters'}), 400user.set_password(data['password'])if 'sidebar_config' in data:@@ -573,7 +606,13 @@ def update_current_user():db.session.commit()- return jsonify({'user': user.to_dict()}), 200+ response = {'user': user.to_dict()}+ if 'password' in data:+ # Keep this freshly authenticated browser signed in; every prior+ # access/refresh token (including its old pair) has been revoked.+ access_token, refresh_token = issue_session_tokens(user.id)+ response.update(access_token=access_token, refresh_token=refresh_token)+ return jsonify(response), 200# ==========================================@@ -668,8 +707,7 @@ def passkey_authenticate():AuditService.log_login(user.id, success=True, details={'method': 'passkey'})db.session.commit()- access_token = create_access_token(identity=user.id)- refresh_token = create_refresh_token(identity=user.id)+ access_token, refresh_token = issue_session_tokens(user.id)return jsonify({'user': user.to_dict(),diff --git a/backend/app/api/sso.py b/backend/app/api/sso.pyindex 85a99dfd..223a4463 100644--- a/backend/app/api/sso.py+++ b/backend/app/api/sso.py@@ -1,8 +1,8 @@"""SSO / OAuth API blueprint."""-from datetime import datetime+from datetime import datetime, timedeltafrom flask import Blueprint, request, jsonify, sessionfrom flask_jwt_extended import (- create_access_token, create_refresh_token, jwt_required, get_jwt_identity+ create_access_token, jwt_required, get_jwt_identity)from app import dbfrom app.models import AuditLog@@ -11,6 +11,7 @@ from app.services import sso_servicefrom app.services.settings_service import SettingsServicefrom app.services.audit_service import AuditServicefrom app.middleware.rbac import admin_required, get_current_user+from app.middleware.session_auth import issue_session_tokensfrom app.error_reporting import record_unexpected, unexpected_responsesso_bp = Blueprint('sso', __name__)@@ -290,7 +291,7 @@ def _complete_sso_login(user, provider, is_new):temp_token = create_access_token(identity=user.id,additional_claims={'2fa_pending': True},- expires_delta=False,+ expires_delta=timedelta(minutes=5),)return jsonify({'requires_2fa': True,@@ -305,8 +306,7 @@ def _complete_sso_login(user, provider, is_new):AuditService.log_login(user.id, success=True, details={'provider': provider, 'is_new': is_new})db.session.commit()- access_token = create_access_token(identity=user.id)- refresh_token = create_refresh_token(identity=user.id)+ access_token, refresh_token = issue_session_tokens(user.id)return jsonify({'user': user.to_dict(),diff --git a/backend/app/api/two_factor.py b/backend/app/api/two_factor.pyindex 062d0456..fbb81696 100644--- a/backend/app/api/two_factor.py+++ b/backend/app/api/two_factor.py@@ -8,6 +8,7 @@ import loggingfrom flask import Blueprint, request, jsonifyfrom flask_jwt_extended import jwt_required, get_jwt_identityfrom app import limiter+from app.middleware.session_auth import issue_session_tokensfrom app.models import Userfrom app.services.totp_service import TOTPService, TwoFactorSetupfrom app.services import auth_throttle_service@@ -171,7 +172,7 @@ def verify_2fa_code():This endpoint is used when login returns requires_2fa=true.Expects a temporary token from the login response."""- from flask_jwt_extended import create_access_token, create_refresh_token, decode_token+ from flask_jwt_extended import decode_tokenfrom app import db# Per-IP brute-force throttle — 2FA codes are a small keyspace, so guessing@@ -205,9 +206,10 @@ def verify_2fa_code():except Exception as e:return jsonify({'error': 'Invalid or expired token'}), 401- user = User.query.get(user_id)+ from app.middleware.session_auth import validate_session_claims+ user = validate_session_claims(token_data, allow_pending=True)if not user:- return jsonify({'error': 'User not found'}), 404+ return jsonify({'error': 'Invalid or expired token'}), 401if not user.totp_enabled:return jsonify({'error': '2FA is not enabled for this account'}), 400@@ -219,8 +221,7 @@ def verify_2fa_code():user.reset_failed_login()db.session.commit()- access_token = create_access_token(identity=user.id)- refresh_token = create_refresh_token(identity=user.id)+ access_token, refresh_token = issue_session_tokens(user.id)return jsonify({'user': user.to_dict(),@@ -239,8 +240,7 @@ def verify_2fa_code():user.reset_failed_login()db.session.commit()- access_token = create_access_token(identity=user.id)- refresh_token = create_refresh_token(identity=user.id)+ access_token, refresh_token = issue_session_tokens(user.id)# Warn about remaining backup codesremaining = len(user.get_backup_codes())diff --git a/backend/app/middleware/api_key_auth.py b/backend/app/middleware/api_key_auth.pyindex bd853806..754eee58 100644--- a/backend/app/middleware/api_key_auth.py+++ b/backend/app/middleware/api_key_auth.py@@ -8,6 +8,10 @@ def register_api_key_auth(app):@app.before_requestdef authenticate_api_key():"""Check for X-API-Key header and validate."""+ # Keep credentials request-local even when an embedding application+ # deliberately keeps its Flask application context across requests.+ g.pop('api_key', None)+ g.pop('api_key_user', None)api_key_header = request.headers.get('X-API-Key')if not api_key_header:@@ -19,6 +23,11 @@ def register_api_key_auth(app):if not api_key:return jsonify({'error': 'Invalid or expired API key'}), 401+ from app.middleware.api_scope_middleware import enforce_request_scope+ denied = enforce_request_scope(api_key)+ if denied is not None:+ return denied+# Record usage against the trusted client IP (see app.utils.client_ip).from app.utils.client_ip import get_client_ipapi_key.record_usage(get_client_ip())diff --git a/backend/app/middleware/api_scope_middleware.py b/backend/app/middleware/api_scope_middleware.pyindex b43e3abf..e51cb352 100644--- a/backend/app/middleware/api_scope_middleware.py+++ b/backend/app/middleware/api_scope_middleware.py@@ -13,7 +13,7 @@ shared between the web UI (JWT) and programmatic clients (API keys)."""from functools import wraps-from flask import g, jsonify+from flask import current_app, g, jsonify, request# ---------------------------------------------------------------------------@@ -78,6 +78,26 @@ SCOPES = [SCOPE_KEYS = {entry['key'] for entry in SCOPES}+def enforce_request_scope(api_key):+ """Fail closed for restricted keys when a route has no scope policy.++ Role checks alone cannot constrain an administrator-owned read-only key.+ Legacy empty scope lists, like '*', retain their existing full-access+ meaning; both still pass through the route's authentication/RBAC policy.+ """+ assigned = api_key.get_scopes()+ if not assigned or FULL_ACCESS_SCOPE in assigned:+ return None+ view = current_app.view_functions.get(request.endpoint)+ required = getattr(view, '_sk_api_scopes', ()) if view else ()+ if not required:+ return jsonify({'error': 'This endpoint does not allow restricted API keys'}), 403+ for scope in required:+ if not api_key.has_scope(scope):+ return jsonify({'error': f'Insufficient API key scope: {scope}'}), 403+ return None++def require_scope(*scopes):"""Enforce that an API-key request carries ALL of ``scopes``.@@ -113,5 +133,9 @@ def require_scope(*scopes):}), 403# JWT/session requests pass through (governed by RBAC).return fn(*args, **kwargs)+ # functools.wraps preserves this metadata through outer RBAC wrappers.+ # Merge nested declarations: a later decorator may only add constraints.+ wrapper._sk_api_scopes = tuple(dict.fromkeys(+ (*getattr(fn, '_sk_api_scopes', ()), *scopes)))return wrapperreturn decoratordiff --git a/backend/app/middleware/session_auth.py b/backend/app/middleware/session_auth.pynew file mode 100644index 00000000..f806a5b2--- /dev/null+++ b/backend/app/middleware/session_auth.py@@ -0,0 +1,61 @@+"""Browser-session policy shared by HTTP, sockets, and long-running work."""+import time+from functools import wraps++from flask import g, jsonify+from flask_jwt_extended import get_jwt, verify_jwt_in_request+++def issue_session_tokens(user_id):+ """Issue one browser's access/refresh pair with an explicit shared id."""+ import secrets+ from flask_jwt_extended import create_access_token, create_refresh_token+ claims = {'session_id': secrets.token_hex(16)}+ return (create_access_token(identity=user_id, additional_claims=claims),+ create_refresh_token(identity=user_id, additional_claims=claims))+++def validate_session_claims(claims, *, allow_pending=False, token_type='access'):+ """Return the live user only for an unexpired, unrevoked session JWT."""+ from app.models import User, RevokedSession++ if not isinstance(claims, dict) or claims.get('type') != token_type:+ return None+ if claims.get('2fa_pending') and not allow_pending:+ return None+ session_id = claims.get('session_id')+ if not isinstance(session_id, str) or len(session_id) != 32:+ return None+ if RevokedSession.query.filter_by(session_id=session_id).first() is not None:+ return None+ expiration = claims.get('exp')+ if not isinstance(expiration, (int, float)) or expiration <= time.time():+ return None+ try:+ user_id = int(claims['sub'])+ except (KeyError, TypeError, ValueError):+ return None+ user = User.query.populate_existing().filter_by(id=user_id).first()+ if (not user or not user.is_active or not claims.get('auth_version')+ or claims['auth_version'] != user.auth_version):+ return None+ return user+++def session_required(fn):+ """Explicit JWT-only policy for actions on the caller's browser sessions.++ Credential/session administration must never turn a scoped API key into+ unrestricted browser credentials, even when its owner is an admin.+ """+ @wraps(fn)+ def wrapper(*args, **kwargs):+ if getattr(g, 'api_key_user', None):+ return jsonify({'error': 'Browser authentication required'}), 403+ verify_jwt_in_request()+ g.session_user = validate_session_claims(get_jwt())+ if not g.session_user:+ return jsonify({'error': 'Session is no longer valid'}), 401+ return fn(*args, **kwargs)+ wrapper._sk_authz = ('session_required',)+ return wrapperdiff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.pyindex 01bfcd3e..1fef9d75 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -2,6 +2,7 @@# FKs (the alternative is an IntegrityError on every parent hard-delete).from app.models import _delete_cascade_policy # noqa: F401from app.models.user import User+from app.models.revoked_session import RevokedSessionfrom app.models.application import Applicationfrom app.models.domain import Domainfrom app.models.env_variable import EnvironmentVariable, EnvironmentVariableHistorydiff --git a/backend/app/models/revoked_session.py b/backend/app/models/revoked_session.pynew file mode 100644index 00000000..3b0673bf--- /dev/null+++ b/backend/app/models/revoked_session.py@@ -0,0 +1,13 @@+"""Persistent session-family revocations (access and refresh share an id)."""+from datetime import datetime+from app import db+++class RevokedSession(db.Model):+ __tablename__ = 'revoked_sessions'++ session_id = db.Column(db.String(32), primary_key=True)+ user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'),+ nullable=False, index=True)+ revoked_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)+ user = db.relationship('User', backref=db.backref('revoked_sessions', lazy='dynamic'))diff --git a/backend/app/models/user.py b/backend/app/models/user.pyindex 0f52271b..294adc0b 100644--- a/backend/app/models/user.py+++ b/backend/app/models/user.py@@ -4,6 +4,7 @@ from werkzeug.security import generate_password_hash, check_password_hashfrom app import dbfrom app.models.json_column_mixin import JsonColumnMixinimport json+import secretsclass User(JsonColumnMixin, db.Model):@@ -23,6 +24,8 @@ class User(JsonColumnMixin, db.Model):role = db.Column(db.String(20), default='developer') # 'admin', 'developer', 'viewer'permissions = db.Column(db.Text, nullable=True) # JSON per-feature read/write flagsis_active = db.Column(db.Boolean, default=True)+ auth_version = db.Column(db.String(32), nullable=False,+ default=lambda: secrets.token_hex(16), server_default='0')created_at = db.Column(db.DateTime, default=datetime.utcnow, index=True)updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)last_login_at = db.Column(db.DateTime, nullable=True)@@ -134,6 +137,22 @@ class User(JsonColumnMixin, db.Model):def set_password(self, password):self.password_hash = generate_password_hash(password)+ self.revoke_sessions()++ @validates('is_active')+ def _invalidate_disabled_sessions(self, key, active):+ if not active:+ self.revoke_sessions()+ return active++ def revoke_sessions(self):+ """Invalidate access/refresh/MFA tokens and unused login links."""+ self.auth_version = secrets.token_hex(16)+ if self.id is not None:+ from app.models.login_link import LoginLink+ LoginLink.query.filter(+ (LoginLink.user_id == self.id) | (LoginLink.created_by_id == self.id)+ ).delete(synchronize_session=False)def check_password(self, password):if not self.password_hash:diff --git a/backend/app/services/passkey_service.py b/backend/app/services/passkey_service.pyindex a30b838a..9bf7f0d2 100644--- a/backend/app/services/passkey_service.py+++ b/backend/app/services/passkey_service.py@@ -8,10 +8,15 @@ from typing import Dict, List, Optionalfrom webauthn import generate_registration_options, verify_registration_responsefrom webauthn import generate_authentication_options, verify_authentication_response+from webauthn import options_to_jsonfrom webauthn.helpers.structs import (- RegistrationResult,- AuthenticationResult,+ AttestationConveyancePreference,+ AuthenticatorAttachment,+ AuthenticatorSelectionCriteria,+ AuthenticatorTransport,PublicKeyCredentialDescriptor,+ ResidentKeyRequirement,+ UserVerificationRequirement,)from webauthn.helpers.exceptions import InvalidRegistrationResponse, InvalidAuthenticationResponse@@ -100,15 +105,15 @@ class PasskeyService:user_display_name=user.username or user.email,challenge=os.urandom(32),timeout=60000,- attestation='none',- authenticator_selection={- 'resident_key': 'preferred',- 'user_verification': 'preferred',- 'authenticator_attachment': 'platform',- },+ attestation=AttestationConveyancePreference.NONE,+ authenticator_selection=AuthenticatorSelectionCriteria(+ resident_key=ResidentKeyRequirement.PREFERRED,+ user_verification=UserVerificationRequirement.REQUIRED,+ authenticator_attachment=AuthenticatorAttachment.PLATFORM,+ ),)cls._set_challenge(user.id, 'register', options.challenge)- return json.loads(options.json())+ return json.loads(options_to_json(options))@classmethoddef verify_registration(cls, user: User, credential: Dict, device_name: str = '') -> Dict:@@ -118,11 +123,12 @@ class PasskeyService:return {'success': False, 'error': 'Registration challenge expired or missing'}try:- result: RegistrationResult = verify_registration_response(+ result = verify_registration_response(credential=credential,expected_challenge=challenge,expected_rp_id=_get_rp_id(),expected_origin=_get_origin(),+ require_user_verification=True,)except InvalidRegistrationResponse as e:return {'success': False, 'error': str(e)}@@ -139,8 +145,9 @@ class PasskeyService:sign_count=result.sign_count,device_name=device_name or 'Passkey',)- if credential.get('transports'):- passkey.set_transports(credential['transports'])+ transports = credential.get('transports') or credential.get('response', {}).get('transports')+ if transports:+ passkey.set_transports(transports)db.session.add(passkey)db.session.commit()@@ -154,7 +161,11 @@ class PasskeyService:if user:creds = PasskeyCredential.query.filter_by(user_id=user.id, is_active=True).all()allow_credentials = [- PublicKeyCredentialDescriptor(id=_b64decode_url(c.credential_id), transports=c.get_transports())+ PublicKeyCredentialDescriptor(+ id=_b64decode_url(c.credential_id),+ transports=[AuthenticatorTransport(t) for t in c.get_transports()+ if t in {item.value for item in AuthenticatorTransport}],+ )for c in creds]@@ -163,12 +174,12 @@ class PasskeyService:challenge=os.urandom(32),timeout=60000,allow_credentials=allow_credentials,- user_verification='preferred',+ user_verification=UserVerificationRequirement.REQUIRED,)# Store challenge globally or per-user. We store per-user if known.challenge_user_id = user.id if user else 0cls._set_challenge(challenge_user_id, 'auth', options.challenge)- return json.loads(options.json())+ return json.loads(options_to_json(options))@classmethoddef verify_authentication(cls, credential: Dict, user: Optional[User] = None) -> Dict:@@ -183,17 +194,18 @@ class PasskeyService:return {'success': False, 'error': 'Missing credential id'}passkey = PasskeyCredential.query.filter_by(credential_id=credential_id_b64, is_active=True).first()- if not passkey:+ if not passkey or (user is not None and passkey.user_id != user.id):return {'success': False, 'error': 'Unknown passkey'}try:- result: AuthenticationResult = verify_authentication_response(+ result = verify_authentication_response(credential=credential,expected_challenge=challenge,expected_rp_id=_get_rp_id(),expected_origin=_get_origin(),credential_public_key=_b64decode_url(passkey.public_key),credential_current_sign_count=passkey.sign_count,+ require_user_verification=True,)except InvalidAuthenticationResponse as e:return {'success': False, 'error': str(e)}diff --git a/backend/migrations/versions/097_user_auth_version.py b/backend/migrations/versions/097_user_auth_version.pynew file mode 100644index 00000000..8cc5578b--- /dev/null+++ b/backend/migrations/versions/097_user_auth_version.py@@ -0,0 +1,33 @@+"""Persist the revocation epoch for all browser authentication tokens.++Existing JWTs lack this claim and intentionally require a fresh login.+"""+from alembic import op+import sqlalchemy as sa++revision = '097_user_auth_version'+down_revision = '096_index_all_fk_columns'+branch_labels = None+depends_on = None+++def upgrade():+ # The initial migration bootstraps from current model metadata, so fresh+ # installs may already have the new schema by the time they reach here.+ inspector = sa.inspect(op.get_bind())+ columns = {column['name'] for column in inspector.get_columns('users')}+ if 'auth_version' not in columns:+ op.add_column('users', sa.Column('auth_version', sa.String(32),+ nullable=False, server_default='0'))+ if 'revoked_sessions' not in inspector.get_table_names():+ op.create_table('revoked_sessions',+ sa.Column('session_id', sa.String(32), primary_key=True),+ sa.Column('user_id', sa.Integer(), sa.ForeignKey('users.id', ondelete='CASCADE'), nullable=False),+ sa.Column('revoked_at', sa.DateTime(), nullable=False))+ op.create_index('ix_revoked_sessions_user_id', 'revoked_sessions', ['user_id'])+++def downgrade():+ op.drop_table('revoked_sessions')+ with op.batch_alter_table('users') as batch:+ batch.drop_column('auth_version')diff --git a/backend/tests/test_api_key_scope_boundary.py b/backend/tests/test_api_key_scope_boundary.pynew file mode 100644index 00000000..908b5f7f--- /dev/null+++ b/backend/tests/test_api_key_scope_boundary.py@@ -0,0 +1,62 @@+"""Restricted keys must never inherit their owner's unrestricted role."""+import pytest+from flask import Blueprint, jsonify++from factories import make_user, headers_for+from app.middleware.api_scope_middleware import require_scope+from app.middleware.rbac import admin_required, auth_required+from app.services.api_key_service import ApiKeyService+++def _headers(db, scopes, role='admin'):+ user = make_user(db, role=role)+ _, raw_key = ApiKeyService.create_key(user.id, name='scope-boundary', scopes=scopes)+ return {'X-API-Key': raw_key}++[email protected]('scopes', [['apps:read'], ['read'], ['apps:*'], ['write']])+def test_restricted_admin_key_cannot_modify_unscoped_ai_settings(client, db_session, scopes):+ response = client.put('/api/v1/ai/settings', headers=_headers(db_session, scopes),+ json={'ai_enabled': True})+ assert response.status_code == 403+ assert response.json['error'] == 'This endpoint does not allow restricted API keys'+++def test_scope_declarations_are_required_and_do_not_replace_role_policy(app, db_session):+ bp = Blueprint('scope_boundary', __name__)++ @bp.route('/read')+ @auth_required()+ @require_scope('apps:read')+ def read():+ return jsonify({'ok': True})++ @bp.route('/write', methods=['PUT'])+ @admin_required+ @require_scope('apps:write')+ def write():+ return jsonify({'ok': True})++ @bp.route('/undeclared', methods=['PUT'])+ @admin_required+ def undeclared():+ return jsonify({'ok': True})++ app.register_blueprint(bp, url_prefix='/__scope_boundary')+ client = app.test_client()+ read_key = _headers(db_session, ['apps:read'])+ assert client.get('/__scope_boundary/read', headers=read_key).status_code == 200+ assert client.put('/__scope_boundary/write', headers=read_key).status_code == 403+ assert client.put('/__scope_boundary/undeclared', headers=read_key).status_code == 403+ wrong_resource = _headers(db_session, ['databases:read'])+ assert client.get('/__scope_boundary/read', headers=wrong_resource).status_code == 403+ wildcard = _headers(db_session, ['apps:*'])+ assert client.put('/__scope_boundary/write', headers=wildcard).status_code == 200+ assert client.put('/__scope_boundary/undeclared', headers=wildcard).status_code == 403+ full = _headers(db_session, ['*'])+ assert client.put('/__scope_boundary/undeclared', headers=full).status_code == 200+ viewer = _headers(db_session, ['*'], role='viewer')+ assert client.put('/__scope_boundary/write', headers=viewer).status_code == 403+ jwt = headers_for(make_user(db_session, role='admin'))+ assert client.put('/__scope_boundary/undeclared', headers=jwt).status_code == 200diff --git a/backend/tests/test_passkey_security.py b/backend/tests/test_passkey_security.pynew file mode 100644index 00000000..6107b1f9--- /dev/null+++ b/backend/tests/test_passkey_security.py@@ -0,0 +1,134 @@+"""Real pinned WebAuthn verifier coverage with locally signed synthetic credentials."""+import hashlib+import json++import cbor2+import pytest+from cryptography.hazmat.primitives import hashes+from cryptography.hazmat.primitives.asymmetric import ec+from flask_jwt_extended import decode_token++from app import db+from app.models import PasskeyCredential+from app.services.passkey_service import PasskeyService, _b64decode_url, _b64encode_url+from factories import make_user++[email protected](autouse=True)+def relying_party(monkeypatch):+ monkeypatch.setenv('SERVERKIT_PASSKEY_RP_ID', 'localhost')+ monkeypatch.setenv('SERVERKIT_PASSKEY_ORIGIN', 'http://localhost')+++def _key_material():+ key = ec.generate_private_key(ec.SECP256R1())+ numbers = key.public_key().public_numbers()+ cose = cbor2.dumps({1: 2, 3: -7, -1: 1,+ -2: numbers.x.to_bytes(32, 'big'), -3: numbers.y.to_bytes(32, 'big')})+ return key, cose+++def _client_data(challenge, ceremony):+ return json.dumps({'type': ceremony, 'challenge': challenge, 'origin': 'http://localhost'}).encode()+++def _registration(challenge, credential_id, cose, verified):+ client_data = _client_data(challenge, 'webauthn.create')+ flags = 0x41 | (0x04 if verified else 0)+ auth_data = (hashlib.sha256(b'localhost').digest() + bytes([flags]) + bytes(4)+ + bytes(16) + len(credential_id).to_bytes(2, 'big') + credential_id + cose)+ attestation = cbor2.dumps({'fmt': 'none', 'attStmt': {}, 'authData': auth_data})+ return {'id': _b64encode_url(credential_id), 'rawId': _b64encode_url(credential_id),+ 'type': 'public-key', 'response': {'clientDataJSON': _b64encode_url(client_data),+ 'attestationObject': _b64encode_url(attestation),+ 'transports': ['internal']}}+++def _assertion(challenge, credential_id, private_key, verified, counter=1):+ client_data = _client_data(challenge, 'webauthn.get')+ auth_data = hashlib.sha256(b'localhost').digest() + bytes([0x05 if verified else 0x01]) + counter.to_bytes(4, 'big')+ signed_data = auth_data + hashlib.sha256(client_data).digest()+ signature = private_key.sign(signed_data, ec.ECDSA(hashes.SHA256()))+ return {'id': _b64encode_url(credential_id), 'rawId': _b64encode_url(credential_id),+ 'type': 'public-key', 'response': {'clientDataJSON': _b64encode_url(client_data),+ 'authenticatorData': _b64encode_url(auth_data),+ 'signature': _b64encode_url(signature)}}+++def test_pinned_webauthn_generates_browser_options_and_requires_uv(app):+ with app.app_context():+ user = make_user(db)+ registration = PasskeyService.begin_registration(user)+ assert registration['authenticatorSelection']['userVerification'] == 'required'+ assert registration['attestation'] == 'none'+ assert len(_b64decode_url(registration['challenge'])) == 32+ _, cose = _key_material()+ saved = PasskeyCredential(user_id=user.id, credential_id=_b64encode_url(b'test'),+ public_key=_b64encode_url(cose))+ saved.set_transports(['internal', 'unknown-future-transport'])+ db.session.add(saved)+ db.session.commit()+ authentication = PasskeyService.begin_authentication(user)+ assert authentication['userVerification'] == 'required'+ assert authentication['allowCredentials'][0]['transports'] == ['internal']+ assert authentication['allowCredentials'][0]['id'] == saved.credential_id+++def test_registration_enforces_uv_with_real_attestation_verifier(app):+ with app.app_context():+ user = make_user(db)+ _, cose = _key_material()+ options = PasskeyService.begin_registration(user)+ credential = _registration(options['challenge'], b'registration-test', cose, False)+ denied = PasskeyService.verify_registration(user, credential)+ assert not denied['success'] and 'verified' in denied['error'].lower()+ assert PasskeyCredential.query.count() == 0+ credential = _registration(options['challenge'], b'registration-test', cose, True)+ accepted = PasskeyService.verify_registration(user, credential)+ assert accepted['success']+ assert accepted['passkey']['transports'] == ['internal']+ assert PasskeyService._get_challenge(user.id, 'register') is None++[email protected]('discoverable', [False, True])+def test_uvless_passkey_cannot_skip_mfa_but_verified_passkey_mints_revocable_pair(app, client, discoverable):+ with app.app_context():+ user = make_user(db, role='admin', totp_enabled=True, password_hash=None)+ key, cose = _key_material()+ cid = b'authentication-test'+ saved = PasskeyCredential(user_id=user.id, credential_id=_b64encode_url(cid), public_key=_b64encode_url(cose))+ db.session.add(saved)+ db.session.commit()+ identity = {} if discoverable else {'user_id': user.id}+ options_response = client.post('/api/v1/auth/passkeys/options/authenticate', json=identity)+ assert options_response.status_code == 200+ challenge = options_response.json['challenge']+ response = client.post('/api/v1/auth/passkeys/authenticate', json={+ **identity, 'credential': _assertion(challenge, cid, key, False),+ })+ assert response.status_code == 401+ assert 'access_token' not in response.json+ response = client.post('/api/v1/auth/passkeys/authenticate', json={+ **identity, 'credential': _assertion(challenge, cid, key, True),+ })+ assert response.status_code == 200, response.json+ access, refresh = response.json['access_token'], response.json['refresh_token']+ assert decode_token(access)['session_id'] == decode_token(refresh)['session_id']+ assert decode_token(access)['auth_version'] == user.auth_version+ assert PasskeyService._get_challenge(0 if discoverable else user.id, 'auth') is None+ assert client.post('/api/v1/auth/logout', headers={'Authorization': f'Bearer {access}'}).status_code == 200+ assert client.post('/api/v1/auth/refresh', headers={'Authorization': f'Bearer {refresh}'}).status_code == 401+++def test_named_user_authentication_rejects_another_users_credential(app):+ with app.app_context():+ expected = make_user(db)+ foreign = make_user(db)+ key, cose = _key_material()+ cid = b'foreign-passkey'+ db.session.add(PasskeyCredential(user_id=foreign.id, credential_id=_b64encode_url(cid),+ public_key=_b64encode_url(cose)))+ db.session.commit()+ options = PasskeyService.begin_authentication(expected)+ assertion = _assertion(options['challenge'], cid, key, True)+ assert not PasskeyService.verify_authentication(assertion, expected)['success']diff --git a/backend/tests/test_route_authz_sweep.py b/backend/tests/test_route_authz_sweep.pyindex b4c4ad53..4265b385 100644--- a/backend/tests/test_route_authz_sweep.py+++ b/backend/tests/test_route_authz_sweep.py@@ -202,6 +202,9 @@ VIEWER_WRITABLE = {# SELF — the viewer acts only on their own account/data.'ai.create_conversation','auth.update_current_user',+ # Registration options bind exclusively to get_jwt_identity(); a viewer+ # may enroll their own passkey, never nominate another account in JSON.+ 'auth.passkey_register_options','notifications.mark_inbox_all_read','notifications.test_user_notification','notifications.unmute_own_email',@@ -218,13 +221,44 @@ VIEWER_WRITABLE = {'docker.get_containers_stats',# PUBLIC transport — agent long-poll fallback; user JWT is ignored here.'agent_poll.disconnect',+ # PUBLIC authentication challenge only; credential verification and UV are+ # required by passkey_authenticate before any session tokens are issued.+ 'auth.passkey_auth_options',}++def test_passkey_enrollment_options_are_self_scoped(client, db_session):+ from app.services.passkey_service import PasskeyService, _b64decode_url+ viewer = make_user(db_session, role='viewer')+ foreign = make_user(db_session, role='admin')+ assert client.post('/api/v1/auth/passkeys/options/register', json={}).status_code == 401+ response = client.post('/api/v1/auth/passkeys/options/register',+ headers=headers_for(viewer), json={'user_id': foreign.id})+ assert response.status_code == 200+ assert _b64decode_url(response.json['user']['id']) == str(viewer.id).encode()+ assert PasskeyService._get_challenge(viewer.id, 'register') is not None+ assert PasskeyService._get_challenge(foreign.id, 'register') is None+++def test_public_passkey_options_issue_only_a_challenge(client, db_session):+ from app.models import PasskeyCredential+ viewer = make_user(db_session, role='viewer')+ response = client.post('/api/v1/auth/passkeys/options/authenticate',+ json={'user_id': viewer.id})+ assert response.status_code == 200+ assert response.json['challenge']+ assert response.json['userVerification'] == 'required'+ assert 'access_token' not in response.json and 'refresh_token' not in response.json+ assert PasskeyCredential.query.count() == 0+# Endpoints skipped by the live-fire net because firing them reaches out to the# network / external providers (slow, flaky in CI). Their gating is asserted by# dedicated per-feature tests, not here._SKIP_ENDPOINTS = {'servers.check_agent_version',+ # Revokes the sweep's shared viewer token, masking later missing gates.+ # Covered with real viewer sessions in test_session_security.py instead.+ 'auth.logout',}diff --git a/backend/tests/test_session_security.py b/backend/tests/test_session_security.pynew file mode 100644index 00000000..e9e633c4--- /dev/null+++ b/backend/tests/test_session_security.py@@ -0,0 +1,241 @@+"""Regression coverage for cross-authentication credential and revocation chains."""+from datetime import timedelta++import pyotp+import pytest+from flask_jwt_extended import create_access_token, decode_token++from factories import make_user, headers_for+from app.services.api_key_service import ApiKeyService++[email protected](autouse=True)+def _isolated_throttles(app):+ from app import limiter+ limiter.reset()+ yield+ limiter.reset()+++def _headers(token):+ return {'Authorization': f'Bearer {token}'}+++def _login(client, user):+ response = client.post('/api/v1/auth/login', json={+ 'email': user.email, 'password': 'password123',+ })+ assert response.status_code == 200, response.get_json()+ return response.get_json()+++def _refresh(client, token):+ return client.post('/api/v1/auth/refresh', headers=_headers(token))+++def test_pending_mfa_cannot_mint_link_and_has_five_minute_expiry(client, db_session):+ user = make_user(db_session, role='admin', password='password123',+ totp_enabled=True, totp_secret=pyotp.random_base32())+ pending = _login(client, user)+ claims = decode_token(pending['temp_token'])+ assert 0 < claims['exp'] - claims['iat'] <= 300+ for path in ('/api/v1/auth/login-links', '/api/v1/auth/logout'):+ response = client.post(path, headers=_headers(pending['temp_token']), json={})+ assert response.status_code in (401, 403)+ assert client.get('/api/v1/auth/me', headers=_headers(pending['temp_token'])).status_code == 401++ verified = client.post('/api/v1/auth/2fa/verify', json={+ 'temp_token': pending['temp_token'], 'code': pyotp.TOTP(user.totp_secret).now(),+ })+ assert verified.status_code == 200+ assert client.get('/api/v1/auth/me', headers=_headers(verified.json['access_token'])).status_code == 200++[email protected]('scopes', [['apps:read'], ['*']])+def test_api_keys_cannot_mint_browser_sessions(client, db_session, scopes):+ user = make_user(db_session, role='admin')+ _, raw_key = ApiKeyService.create_key(user.id, name='session-probe', scopes=scopes)+ # Even combining a valid JWT with a key must not silently ignore the key.+ for headers in ({'X-API-Key': raw_key}, {**headers_for(user), 'X-API-Key': raw_key}):+ response = client.post('/api/v1/auth/login-links', json={}, headers=headers)+ assert response.status_code == 403+++def test_login_link_redemption_respects_target_mfa(client, db_session):+ admin = make_user(db_session, role='admin')+ target = make_user(db_session, totp_enabled=True, totp_secret=pyotp.random_base32())+ created = client.post('/api/v1/auth/login-links', headers=headers_for(admin),+ json={'user_id': target.id})+ assert created.status_code == 201+ redeemed = client.post('/api/v1/auth/login-links/redeem', json={'token': created.json['token']})+ assert redeemed.status_code == 200+ assert redeemed.json['requires_2fa'] is True+ assert 'access_token' not in redeemed.json and 'refresh_token' not in redeemed.json+ result = client.post('/api/v1/auth/2fa/verify', json={+ 'temp_token': redeemed.json['temp_token'], 'code': pyotp.TOTP(target.totp_secret).now(),+ })+ assert result.status_code == 200 and result.json['user']['id'] == target.id+++def test_password_change_requires_current_password_and_revokes_previous_tokens(client, db_session):+ user = make_user(db_session, password='password123')+ original = _login(client, user)+ headers = _headers(original['access_token'])+ for body in ({'password': 'replacement123'},+ {'password': 'replacement123', 'current_password': 'incorrect'}):+ assert client.put('/api/v1/auth/me', headers=headers, json=body).status_code == 403+ updated = client.put('/api/v1/auth/me', headers=headers, json={+ 'password': 'replacement123', 'current_password': 'password123',+ })+ assert updated.status_code == 200+ assert _refresh(client, original['refresh_token']).status_code == 401+ assert client.get('/api/v1/auth/me', headers=headers).status_code == 401+ assert client.get('/api/v1/auth/me', headers=_headers(updated.json['access_token'])).status_code == 200+ assert _refresh(client, updated.json['refresh_token']).status_code == 200+++def test_disable_reenable_and_admin_password_reset_revoke_existing_tokens(client, db_session):+ user = make_user(db_session, password='password123')+ tokens = _login(client, user)+ user.is_active = False+ db_session.session.commit()+ assert client.get('/api/v1/auth/me', headers=_headers(tokens['access_token'])).status_code == 401+ user.is_active = True+ db_session.session.commit()+ assert _refresh(client, tokens['refresh_token']).status_code == 401+ fresh = _login(client, user)+ admin = make_user(db_session, role='admin')+ response = client.put(f'/api/v1/admin/users/{user.id}', headers=headers_for(admin),+ json={'password': 'adminreset123'})+ assert response.status_code == 200+ assert _refresh(client, fresh['refresh_token']).status_code == 401+++def test_logout_revokes_entire_browser_family_but_preserves_other_browser(client, db_session):+ user = make_user(db_session, role='viewer', password='password123')+ first = _login(client, user)+ second = _login(client, user)+ refreshed = _refresh(client, first['refresh_token'])+ assert refreshed.status_code == 200+ assert decode_token(first['access_token'])['session_id'] == decode_token(first['refresh_token'])['session_id']+ assert client.post('/api/v1/auth/logout', headers=_headers(first['access_token'])).status_code == 200+ for token in (first['access_token'], refreshed.json['access_token']):+ assert client.get('/api/v1/auth/me', headers=_headers(token)).status_code == 401+ assert _refresh(client, first['refresh_token']).status_code == 401+ assert client.get('/api/v1/auth/me', headers=_headers(second['access_token'])).status_code == 200+ assert _refresh(client, second['refresh_token']).status_code == 200++[email protected]('change', ['disable', 'password'])+def test_revoked_pending_mfa_cannot_finish_login(client, db_session, change):+ user = make_user(db_session, password='password123', totp_enabled=True,+ totp_secret=pyotp.random_base32())+ pending = _login(client, user)+ if change == 'disable':+ user.is_active = False+ else:+ user.set_password('resetpassword123')+ db_session.session.commit()+ response = client.post('/api/v1/auth/2fa/verify', json={+ 'temp_token': pending['temp_token'], 'code': pyotp.TOTP(user.totp_secret).now(),+ })+ assert response.status_code == 401+++def test_unexpired_legacy_or_expired_mfa_tokens_are_rejected(client, db_session):+ user = make_user(db_session, totp_enabled=True, totp_secret=pyotp.random_base32())+ legacy = create_access_token(identity=user.id, additional_claims={'auth_version': None})+ assert client.get('/api/v1/auth/me', headers=_headers(legacy)).status_code == 401+ for expiration in (False, timedelta(seconds=-1)):+ pending = create_access_token(identity=user.id, additional_claims={'2fa_pending': True},+ expires_delta=expiration)+ response = client.post('/api/v1/auth/2fa/verify', json={+ 'temp_token': pending, 'code': pyotp.TOTP(user.totp_secret).now(),+ })+ assert response.status_code == 401+++def test_password_reset_invalidates_outstanding_login_links(client, db_session):+ admin = make_user(db_session, role='admin')+ target = make_user(db_session)+ created = client.post('/api/v1/auth/login-links', headers=headers_for(admin),+ json={'user_id': target.id})+ assert created.status_code == 201+ target.set_password('resetpassword123')+ db_session.session.commit()+ assert client.post('/api/v1/auth/login-links/redeem',+ json={'token': created.json['token']}).status_code == 401+++def test_sso_tokens_share_session_and_pending_tokens_expire(app, db_session):+ from app.api.sso import _complete_sso_login+ user = make_user(db_session, auth_provider='oidc', password_hash=None)+ with app.test_request_context('/api/v1/sso/callback/oidc'):+ response, status = _complete_sso_login(user, 'oidc', False)+ assert status == 200+ pair = response.get_json()+ assert decode_token(pair['access_token'])['session_id'] == decode_token(pair['refresh_token'])['session_id']+ user.totp_enabled = True+ db_session.session.commit()+ response, status = _complete_sso_login(user, 'oidc', False)+ assert status == 200+ claims = decode_token(response.get_json()['temp_token'])+ assert claims['2fa_pending'] is True+ assert 0 < claims['exp'] - claims['iat'] <= 300+++def test_refresh_cannot_renew_recent_authentication(client, db_session):+ import time+ from flask_jwt_extended import create_refresh_token+ user = make_user(db_session, auth_provider='oidc', password_hash=None)+ stale_auth = int(time.time()) - 600+ refresh_token = create_refresh_token(identity=user.id, additional_claims={'auth_time': stale_auth})+ refreshed = _refresh(client, refresh_token)+ assert refreshed.status_code == 200+ token = refreshed.json['access_token']+ assert decode_token(token)['auth_time'] == stale_auth+ assert client.put('/api/v1/auth/me', headers=_headers(token),+ json={'password': 'replacement123'}).status_code == 403+++def test_session_migration_upgrades_existing_users_and_is_repeatable(tmp_path, monkeypatch):+ import importlib.util+ from pathlib import Path+ import sqlalchemy as sa+ from alembic.migration import MigrationContext+ from alembic.operations import Operations++ path = Path(__file__).parents[1] / 'migrations/versions/097_user_auth_version.py'+ spec = importlib.util.spec_from_file_location('session_migration', path)+ migration = importlib.util.module_from_spec(spec)+ spec.loader.exec_module(migration)+ engine = sa.create_engine('sqlite:///' + (tmp_path / 'previous.db').as_posix())+ with engine.begin() as connection:+ connection.exec_driver_sql('CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT)')+ connection.exec_driver_sql("INSERT INTO users VALUES (1, 'existing')")+ monkeypatch.setattr(migration, 'op', Operations(MigrationContext.configure(connection)))+ migration.upgrade()+ migration.upgrade()+ assert connection.exec_driver_sql('SELECT username, auth_version FROM users').one() == ('existing', '0')+ assert 'revoked_sessions' in sa.inspect(connection).get_table_names()+ migration.downgrade()+ assert 'auth_version' not in {c['name'] for c in sa.inspect(connection).get_columns('users')}+ engine.dispose()+++def test_revocation_rows_cascade_on_user_deletion(db_session):+ from app.models import RevokedSession+ user = make_user(db_session)+ db_session.session.add(RevokedSession(session_id='a' * 32, user_id=user.id))+ db_session.session.commit()+ assert RevokedSession.query.filter_by(user_id=user.id).count() == 1+ connection = db_session.session.connection()+ connection.exec_driver_sql('PRAGMA foreign_keys=ON')+ assert connection.exec_driver_sql('PRAGMA foreign_keys').scalar() == 1+ try:+ db_session.session.delete(user)+ db_session.session.commit()+ assert RevokedSession.query.count() == 0+ finally:+ db_session.session.rollback()+ db_session.session.connection().exec_driver_sql('PRAGMA foreign_keys=OFF')diff --git a/docs/MIGRATION_INVENTORY.md b/docs/MIGRATION_INVENTORY.mdindex e7989f1d..826a452c 100644--- a/docs/MIGRATION_INVENTORY.md+++ b/docs/MIGRATION_INVENTORY.md@@ -16,7 +16,7 @@ debt. Regenerate with `python scripts/generate-migration-inventory.py`.| Routes on bare @jwt_required() | auth_required() / role decorators | 608 | 608 | REGISTERED EXCEPTION: JWT-only is the deliberate default; conversion grants API-key access and happens per route, on decision || HTTP statuses chosen by sniffing error text | typed errors from app.exceptions | 0 | 0 | INVARIANT at 0 - migration completed 2026-08-19 || API crashes swallowed without recording | app.error_reporting | 0 | 0 | INVARIANT at 0 |-| Hand-shaped {'error': ...} bodies in app/api | typed errors + the global handler | 1145 | 1150 | migrate when touched; new endpoints raise |+| Hand-shaped {'error': ...} bodies in app/api | typed errors + the global handler | 1144 | 1150 | migrate when touched; new endpoints raise || Raw subprocess calls outside the runners | app/utils/system.py runners | 24 | 24 | migrate when touched || Controller-boundary violations (routes doing service work) | service layer extraction | 511 | 511 | migrate when touched (first-wave ratchet) || raw api.* calls in pages/ | E1: useServerQuery/useServerMutation | 405 | 405 | migrate when touched |diff --git a/frontend/src/components/settings/SecuritySettingsTab.jsx b/frontend/src/components/settings/SecuritySettingsTab.jsxindex 7c69991a..26837bbe 100644--- a/frontend/src/components/settings/SecuritySettingsTab.jsx+++ b/frontend/src/components/settings/SecuritySettingsTab.jsx@@ -176,7 +176,10 @@ const SecuritySettingsTab = () => {setLoading(true);try {- await updateUser({ password: formData.newPassword });+ await updateUser({+ password: formData.newPassword,+ current_password: formData.currentPassword,+ });setMessage({ type: 'success', text: 'Password changed successfully' });setFormData({ currentPassword: '', newPassword: '', confirmPassword: '' });} catch (err) {diff --git a/frontend/src/contexts/AuthContext.jsx b/frontend/src/contexts/AuthContext.jsxindex 368865cd..b3777b41 100644--- a/frontend/src/contexts/AuthContext.jsx+++ b/frontend/src/contexts/AuthContext.jsx@@ -144,9 +144,14 @@ export function AuthProvider({ children }) {}));}- function logout() {- api.logout();- setUser(null);+ async function logout() {+ try {+ await api.logout();+ } catch (err) {+ console.error('Server sign-out failed:', err);+ } finally {+ setUser(null);+ }}async function updateUser(data) {diff --git a/frontend/src/pages/Login.jsx b/frontend/src/pages/Login.jsxindex e2697c27..6132abda 100644--- a/frontend/src/pages/Login.jsx+++ b/frontend/src/pages/Login.jsx@@ -56,6 +56,13 @@ const Login = () => {setRedeemingLink(true);api.redeemLoginLink(token).then((response) => {+ if (response.requires_2fa) {+ setRequires2FA(true);+ setTempToken(response.temp_token);+ setRedeemingLink(false);+ navigate('/login', { replace: true });+ return;+ }setUser(response.user);navigate(consumeRedirect(), { replace: true });})diff --git a/frontend/src/services/api/__tests__/auth.test.mjs b/frontend/src/services/api/__tests__/auth.test.mjsnew file mode 100644index 00000000..cb0eae4c--- /dev/null+++ b/frontend/src/services/api/__tests__/auth.test.mjs@@ -0,0 +1,50 @@+import test from 'node:test';+import assert from 'node:assert/strict';+import { login, logout, redeemLoginLink, updateCurrentUser } from '../auth.js';++test('MFA challenges do not persist incomplete session credentials', async () => {+ const challenge = { requires_2fa: true, temp_token: 'pending' };+ const client = {+ request: async () => challenge,+ setTokens: () => assert.fail('MFA challenge must not install session tokens'),+ };+ assert.equal(await login.call(client, 'user', 'password'), challenge);+ assert.equal(await redeemLoginLink.call(client, 'link'), challenge);+});++test('password changes replace the revoked token pair before returning', async () => {+ const replacement = { user: { id: 1 }, access_token: 'new-access', refresh_token: 'new-refresh' };+ const events = [];+ const client = {+ request: async (endpoint, options) => {+ assert.equal(endpoint, '/auth/me');+ assert.equal(options.body.current_password, 'current');+ return replacement;+ },+ setTokens: (...pair) => events.push(pair),+ };+ assert.equal(await updateCurrentUser.call(client, { password: 'new-password', current_password: 'current' }), replacement);+ assert.deepEqual(events, [['new-access', 'new-refresh']]);+});++test('logout submits server revocation before clearing local credentials', async () => {+ const events = [];+ await logout.call({+ request: async (endpoint, options) => {+ assert.equal(endpoint, '/auth/logout');+ assert.equal(options.method, 'POST');+ events.push('revoke');+ },+ clearTokens: () => events.push('clear'),+ });+ assert.deepEqual(events, ['revoke', 'clear']);+});++test('logout still clears credentials when server revocation fails', async () => {+ let cleared = false;+ await assert.rejects(logout.call({+ request: async () => { throw new Error('offline'); },+ clearTokens: () => { cleared = true; },+ }), /offline/);+ assert.equal(cleared, true);+});diff --git a/frontend/src/services/api/auth.js b/frontend/src/services/api/auth.jsindex c3796aa1..4e22005d 100644--- a/frontend/src/services/api/auth.js+++ b/frontend/src/services/api/auth.js@@ -10,7 +10,9 @@ export async function login(email, password) {method: 'POST',body: { email, password },});- this.setTokens(data.access_token, data.refresh_token);+ if (data.access_token) {+ this.setTokens(data.access_token, data.refresh_token);+ }return data;}@@ -37,7 +39,11 @@ export async function completeOnboarding(useCases, installedExtensions = [], sec}export async function logout() {- this.clearTokens();+ try {+ await this.request('/auth/logout', { method: 'POST' });+ } finally {+ this.clearTokens();+ }}export async function getCurrentUser() {@@ -45,10 +51,14 @@ export async function getCurrentUser() {}export async function updateCurrentUser(data) {- return this.request('/auth/me', {+ const response = await this.request('/auth/me', {method: 'PUT',body: data});+ if (response.access_token) {+ this.setTokens(response.access_token, response.refresh_token);+ }+ return response;}// One-time login links@@ -72,7 +82,9 @@ export async function redeemLoginLink(token) {method: 'POST',body: { token },});- this.setTokens(data.access_token, data.refresh_token);+ if (data.access_token) {+ this.setTokens(data.access_token, data.refresh_token);+ }return data;}