Skip to content

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.

fix(auth): enforce MFA, scoped keys, and revocable sessions

Juan Denisc8c93a8e0c7b
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index eef51398..07cc6fa2 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -20,6 +20,26 @@ migrate = Migrate()
@jwt.user_identity_loader
def _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 init
socketio = None
@@ -451,25 +471,9 @@ def create_app(config_name=None):
# Request body size limit
app.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.py
index 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, g
from sqlalchemy import func
from 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, limiter
from 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_tokens
from app.services.settings_service import SettingsService
from app.services.audit_service import AuditService
from 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_required
def 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',
+ }), 200
user.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'}), 400
user.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.py
index 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, timedelta
from flask import Blueprint, request, jsonify, session
from 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 db
from app.models import AuditLog
@@ -11,6 +11,7 @@ from app.services import sso_service
from app.services.settings_service import SettingsService
from app.services.audit_service import AuditService
from app.middleware.rbac import admin_required, get_current_user
+from app.middleware.session_auth import issue_session_tokens
from app.error_reporting import record_unexpected, unexpected_response
sso_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.py
index 062d0456..fbb81696 100644
--- a/backend/app/api/two_factor.py
+++ b/backend/app/api/two_factor.py
@@ -8,6 +8,7 @@ import logging
from flask import Blueprint, request, jsonify
from flask_jwt_extended import jwt_required, get_jwt_identity
from app import limiter
+from app.middleware.session_auth import issue_session_tokens
from app.models import User
from app.services.totp_service import TOTPService, TwoFactorSetup
from 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_token
from 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'}), 401
if 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 codes
remaining = len(user.get_backup_codes())
diff --git a/backend/app/middleware/api_key_auth.py b/backend/app/middleware/api_key_auth.py
index 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_request
def 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_ip
api_key.record_usage(get_client_ip())
diff --git a/backend/app/middleware/api_scope_middleware.py b/backend/app/middleware/api_scope_middleware.py
index 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 wrapper
return decorator
diff --git a/backend/app/middleware/session_auth.py b/backend/app/middleware/session_auth.py
new file mode 100644
index 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 wrapper
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 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: F401
from app.models.user import User
+from app.models.revoked_session import RevokedSession
from app.models.application import Application
from app.models.domain import Domain
from app.models.env_variable import EnvironmentVariable, EnvironmentVariableHistory
diff --git a/backend/app/models/revoked_session.py b/backend/app/models/revoked_session.py
new file mode 100644
index 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.py
index 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_hash
from app import db
from app.models.json_column_mixin import JsonColumnMixin
import json
+import secrets
class 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 flags
is_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.py
index 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, Optional
from webauthn import generate_registration_options, verify_registration_response
from webauthn import generate_authentication_options, verify_authentication_response
+from webauthn import options_to_json
from 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))
@classmethod
def 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 0
cls._set_challenge(challenge_user_id, 'auth', options.challenge)
- return json.loads(options.json())
+ return json.loads(options_to_json(options))
@classmethod
def 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 == 200
diff --git a/backend/tests/test_passkey_security.py b/backend/tests/test_passkey_security.py
new file mode 100644
index 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.py
index 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.py
new file mode 100644
index 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.md
index 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.jsx
index 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.jsx
index 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.jsx
index 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.mjs
new file mode 100644
index 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.js
index 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;
}