🙌 OpenHands: AI-Driven Development
Migrate all jwt_secret consumers from OpenHandsConfig to JwtService (#14242)
Tim O'Farrell1da9e2b4778a
diff --git a/enterprise/integrations/github/github_view.py b/enterprise/integrations/github/github_view.pyindex 7c74e54f5a..9cf3eab97d 100644--- a/enterprise/integrations/github/github_view.py+++ b/enterprise/integrations/github/github_view.py@@ -22,7 +22,6 @@ from integrations.utils import (from jinja2 import Environmentfrom server.auth.constants import GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEYfrom server.auth.token_manager import TokenManager-from server.config import get_configfrom storage.org_store import OrgStorefrom storage.proactive_conversation_store import ProactiveConversationStorefrom storage.saas_secrets_store import SaasSecretsStore@@ -135,7 +134,9 @@ class GithubIssue(ResolverViewInterface):return user_instructions, conversation_instructionsasync def _get_user_secrets(self):- secrets_store = SaasSecretsStore(self.user_info.keycloak_user_id, get_config())+ secrets_store = await SaasSecretsStore.get_instance(+ None, self.user_info.keycloak_user_id+ )user_secrets = await secrets_store.load()return user_secrets.custom_secrets if user_secrets else Nonediff --git a/enterprise/integrations/gitlab/gitlab_view.py b/enterprise/integrations/gitlab/gitlab_view.pyindex c5cc5f1872..b46e4aa510 100644--- a/enterprise/integrations/gitlab/gitlab_view.py+++ b/enterprise/integrations/gitlab/gitlab_view.py@@ -12,7 +12,6 @@ from integrations.utils import ()from jinja2 import Environmentfrom server.auth.token_manager import TokenManager-from server.config import get_configfrom storage.saas_secrets_store import SaasSecretsStorefrom openhands.agent_server.models import SendMessageRequest@@ -97,7 +96,9 @@ class GitlabIssue(ResolverViewInterface):return user_instructions, conversation_instructionsasync def _get_user_secrets(self):- secrets_store = SaasSecretsStore(self.user_info.keycloak_user_id, get_config())+ secrets_store = await SaasSecretsStore.get_instance(+ None, self.user_info.keycloak_user_id+ )user_secrets = await secrets_store.load()return user_secrets.custom_secrets if user_secrets else Nonediff --git a/enterprise/integrations/slack/slack_manager.py b/enterprise/integrations/slack/slack_manager.pyindex 1d71b49acf..bea2ab3cc4 100644--- a/enterprise/integrations/slack/slack_manager.py+++ b/enterprise/integrations/slack/slack_manager.py@@ -1,6 +1,5 @@from typing import Any-import jwtfrom integrations.manager import Managerfrom integrations.models import Message, SourceTypefrom integrations.slack.slack_errors import SlackError, SlackErrorCode@@ -39,7 +38,7 @@ from openhands.app_server.integrations.service_types import ()from openhands.app_server.user_auth.user_auth import UserAuthfrom openhands.app_server.utils.logger import openhands_logger as logger-from openhands.server.shared import config, server_config+from openhands.server.shared import server_configfrom openhands.server.types import (LLMAuthenticationError,MissingSettingsError,@@ -499,12 +498,9 @@ class SlackManager(Manager[SlackViewInterface]):def _generate_login_link_with_state(self, message: Message) -> str:"""Generate OAuth login link with message state encoded."""- jwt_secret = config.jwt_secret- if not jwt_secret:- raise ValueError('Must configure jwt_secret')- state = jwt.encode(- message.message, jwt_secret.get_secret_value(), algorithm='HS256'- )+ from storage.encrypt_utils import get_jwt_service++ state = get_jwt_service().create_jws_token(message.message)return authorize_url_generator.generate(state)async def handle_slack_error(self, payload: dict, error: SlackError) -> None:diff --git a/enterprise/server/auth/saas_user_auth.py b/enterprise/server/auth/saas_user_auth.pyindex ae9cfb191e..04a8a7fbf4 100644--- a/enterprise/server/auth/saas_user_auth.py+++ b/enterprise/server/auth/saas_user_auth.py@@ -153,7 +153,7 @@ class SaasUserAuth(UserAuth):secrets_store = self.secrets_storeif secrets_store:return secrets_store- secrets_store = SaasSecretsStore(self.user_id, get_config())+ secrets_store = await SaasSecretsStore.get_instance(None, self.user_id)self.secrets_store = secrets_storereturn secrets_store@@ -443,8 +443,9 @@ async def saas_user_auth_from_cookie(request: Request) -> SaasUserAuth | None:async def saas_user_auth_from_signed_token(signed_token: str) -> SaasUserAuth:logger.debug('saas_user_auth_from_signed_token')- jwt_secret = get_config().jwt_secret.get_secret_value()- decoded = jwt.decode(signed_token, jwt_secret, algorithms=['HS256'])+ from storage.encrypt_utils import get_jwt_service++ decoded = get_jwt_service().verify_jws_token(signed_token)logger.debug('saas_user_auth_from_signed_token:decoded')access_token = decoded['access_token']refresh_token = decoded['refresh_token']diff --git a/enterprise/server/auth/token_manager.py b/enterprise/server/auth/token_manager.pyindex dd25c09b3a..74db1c60eb 100644--- a/enterprise/server/auth/token_manager.py+++ b/enterprise/server/auth/token_manager.py@@ -1,14 +1,11 @@import asyncioimport base64-import hashlibimport jsonimport time-from base64 import b64encodefrom urllib.parse import parse_qsimport httpximport jwt-from cryptography.fernet import Fernetfrom jwt.exceptions import DecodeErrorfrom keycloak.exceptions import (KeycloakAuthenticationError,@@ -88,47 +85,25 @@ def _before_sleep_callback(retry_state: RetryCallState) -> None:logger.info(f'Retry attempt {retry_state.attempt_number} for Keycloak operation')-def create_encryption_utility(secret_key: bytes):- """Creates an encryption utility using a 32-byte secret key.-- Args:- secret_key (bytes): A 32-byte secret key- Returns:- tuple: (encrypt_string, decrypt_string) functions.- """- # Convert the 32-byte key into a Fernet key (32 bytes -> urlsafe base64)- fernet_key = b64encode(hashlib.sha256(secret_key).digest())- f = Fernet(fernet_key)-- def encrypt_text(text: str) -> str:- return f.encrypt(text.encode()).decode()-- def encrypt_payload(payload: dict) -> str:- """Encrypts a string and returns the result as a base64 string."""- text = json.dumps(payload)- return encrypt_text(text)+class TokenManager:+ def __init__(self, external: bool = False):+ self.external = external+ from storage.encrypt_utils import get_jwt_service- def decrypt_text(encrypted_text: str) -> str:- return f.decrypt(encrypted_text.encode()).decode()+ self._jwt_svc = get_jwt_service()- def decrypt_payload(encrypted_text: str) -> dict:- """Decrypts a base64 encoded encrypted string."""- text = decrypt_text(encrypted_text)- return json.loads(text)+ def encrypt_text(self, text: str) -> str:+ encrypted = self._jwt_svc.encrypt_value(text)+ return encrypted- return encrypt_payload, decrypt_payload, encrypt_text, decrypt_text+ def decrypt_text(self, encrypted_text: str) -> str:+ return self._jwt_svc.decrypt_value(encrypted_text)+ def encrypt_payload(self, payload: dict) -> str:+ return self.encrypt_text(json.dumps(payload))-class TokenManager:- def __init__(self, external: bool = False):- self.external = external- jwt_secret = get_config().jwt_secret.get_secret_value()- (- self.encrypt_payload,- self.decrypt_payload,- self.encrypt_text,- self.decrypt_text,- ) = create_encryption_utility(jwt_secret.encode())+ def decrypt_payload(self, encrypted_text: str) -> dict:+ return json.loads(self.decrypt_text(encrypted_text))async def get_keycloak_tokens(self, code: str, redirect_uri: str@@ -316,7 +291,7 @@ class TokenManager:raise ValueError(f'No tokens for user: {username}, identity provider: {idp}')- access_token = self.decrypt_text(token_info['access_token'])+ access_token = self.decrypt_text(str(token_info['access_token']))logger.info(f'Got {idp} token: {access_token[0:5]}')return access_tokenexcept httpx.HTTPStatusError as e:@@ -362,8 +337,8 @@ class TokenManager:logger.info(f'Access token expired for {identity_provider}. Refreshing token.')refresh_token = self.decrypt_text(encrypted_refresh_token)token_data = await self._refresh_token(identity_provider, refresh_token)- access_token = token_data['access_token']- refresh_token = token_data['refresh_token']+ access_token = str(token_data['access_token'])+ refresh_token = str(token_data['refresh_token'])access_expiration = token_data['access_token_expires_at']refresh_expiration = token_data['refresh_token_expires_at']diff --git a/enterprise/server/middleware.py b/enterprise/server/middleware.pyindex 6313705e8f..d550a088ee 100644--- a/enterprise/server/middleware.py+++ b/enterprise/server/middleware.py@@ -3,7 +3,6 @@ from typing import Callable, castimport jwtfrom fastapi import Request, Response, statusfrom fastapi.responses import JSONResponse-from pydantic import SecretStrfrom server.auth.auth_error import (AuthError,EmailNotVerifiedError,@@ -17,7 +16,6 @@ from server.utils.url_utils import get_cookie_domain, get_cookie_samesitefrom openhands.app_server.user_auth.user_auth import AuthType, UserAuth, get_user_authfrom openhands.app_server.utils.logger import openhands_logger as logger-from openhands.server.shared import configclass SetAuthCookieMiddleware:@@ -115,21 +113,16 @@ class SetAuthCookieMiddleware:):raise NoCredentialsError- jwt_secret: SecretStr = config.jwt_secret # type: ignore[assignment]if keycloak_auth_cookie:try:- decoded = jwt.decode(- keycloak_auth_cookie,- jwt_secret.get_secret_value(),- algorithms=['HS256'],- )+ from storage.encrypt_utils import get_jwt_service++ decoded = get_jwt_service().verify_jws_token(keycloak_auth_cookie)accepted_tos = decoded.get('accepted_tos')- except jwt.exceptions.InvalidSignatureError:- # If we can't decode the token, treat it as an auth error+ except (jwt.InvalidTokenError, ValueError):logger.warning('Invalid JWT signature detected')raise AuthError('Invalid authentication token')except Exception as e:- # Handle any other JWT decoding errorslogger.warning(f'JWT decode error: {str(e)}')raise AuthError('Invalid authentication token')else:diff --git a/enterprise/server/routes/auth.py b/enterprise/server/routes/auth.pyindex c861caa36a..d7fac4798a 100644--- a/enterprise/server/routes/auth.py+++ b/enterprise/server/routes/auth.py@@ -2,7 +2,7 @@ import base64import jsonimport uuidimport warnings-from datetime import datetime, timezone+from datetime import datetime, timedelta, timezonefrom types import MappingProxyTypefrom typing import Annotated, Optional, castfrom urllib.parse import quote, urlencode@@ -27,7 +27,6 @@ from server.auth.user.user_authorizer import (UserAuthorizer,depends_user_authorizer,)-from server.config import sign_tokenfrom server.constants import (DEPLOYMENT_MODE,IS_FEATURE_ENV,@@ -56,7 +55,6 @@ from openhands.app_server.integrations.service_types import ProviderType, TokenRfrom openhands.app_server.user_auth import get_access_tokenfrom openhands.app_server.user_auth.user_auth import get_user_authfrom openhands.app_server.utils.logger import openhands_logger as logger-from openhands.server.shared import configwith warnings.catch_warnings():warnings.simplefilter('ignore')@@ -93,7 +91,11 @@ def set_response_cookie('refresh_token': keycloak_refresh_token,'accepted_tos': accepted_tos,}- signed_token = sign_token(cookie_data, config.jwt_secret.get_secret_value()) # type: ignore+ from storage.encrypt_utils import get_jwt_service++ signed_token = get_jwt_service().create_jws_token(+ cookie_data, expires_in=timedelta(weeks=1)+ )# Set secure cookie with signed tokendomain = get_cookie_domain()diff --git a/enterprise/server/routes/github_proxy.py b/enterprise/server/routes/github_proxy.pyindex 96091ddcae..e75833940c 100644--- a/enterprise/server/routes/github_proxy.py+++ b/enterprise/server/routes/github_proxy.py@@ -1,4 +1,3 @@-import hashlibimport jsonimport osimport zlib@@ -6,13 +5,11 @@ from base64 import b64decode, b64encodefrom urllib.parse import parse_qs, urlencode, urlparseimport httpx-from cryptography.fernet import Fernetfrom fastapi import FastAPI, Request, Responsefrom fastapi.responses import RedirectResponsefrom server.logger import loggerfrom openhands.app_server.utils.http_session import httpx_verify_option-from openhands.server.shared import configGITHUB_PROXY_ENDPOINTS = bool(os.environ.get('GITHUB_PROXY_ENDPOINTS'))@@ -39,11 +36,9 @@ def add_github_proxy_routes(app: FastAPI):returndef _fernet():- if not config.jwt_secret:- raise ValueError('jwt_secret must be defined on config')- jwt_secret = config.jwt_secret.get_secret_value()- fernet_key = b64encode(hashlib.sha256(jwt_secret.encode()).digest())- return Fernet(fernet_key)+ from storage.encrypt_utils import get_fernet++ return get_fernet()@app.get('/github-proxy/{subdomain}/login/oauth/authorize')def github_proxy_start(request: Request):diff --git a/enterprise/server/routes/integration/slack.py b/enterprise/server/routes/integration/slack.pyindex 7ab4eaadba..c483f1e4ce 100644--- a/enterprise/server/routes/integration/slack.py+++ b/enterprise/server/routes/integration/slack.py@@ -2,7 +2,6 @@ import htmlimport jsonfrom urllib.parse import quote-import jwtfrom fastapi import APIRouter, BackgroundTasks, HTTPException, Requestfrom fastapi.responses import (HTMLResponse,@@ -40,11 +39,12 @@ from storage.slack_team_store import SlackTeamStorefrom storage.slack_user import SlackUserfrom storage.user_store import UserStore+from openhands.app_server.config import depends_jwt_servicefrom openhands.app_server.integrations.service_types import (ProviderTimeoutError,ProviderType,)-from openhands.server.shared import config+from openhands.app_server.services.jwt_service import JwtServicesignature_verifier = SignatureVerifier(signing_secret=SLACK_SIGNING_SECRET)slack_router = APIRouter(prefix='/slack')@@ -66,6 +66,7 @@ token_manager = TokenManager()slack_manager = SlackManager(token_manager)slack_team_store = SlackTeamStore.get_instance()+jwt_service_dependency = depends_jwt_service()@slack_router.get('/install')@@ -77,7 +78,11 @@ async def install(state: str = ''):@slack_router.get('/install-callback')async def install_callback(- request: Request, code: str = '', state: str = '', error: str = ''+ request: Request,+ code: str = '',+ state: str = '',+ error: str = '',+ jwt_service: JwtService = jwt_service_dependency,):"""Callback from slack authentication. Verifies, then forwards into keycloak authentication."""if not code or error:@@ -95,14 +100,6 @@ async def install_callback(status_code=400,)- if not config.jwt_secret:- logger.error('slack_install_callback_error JWT not configured.')- return _html_response(- title='Error',- description=html.escape('JWT not configured'),- status_code=500,- )-try:client = AsyncWebClient() # no prepared token needed for this# Complete the installation by calling oauth.v2.access API method@@ -119,16 +116,12 @@ async def install_callback(# Create a state variable for keycloak oauthpayload = {}if state:- payload = jwt.decode(- state, config.jwt_secret.get_secret_value(), algorithms=['HS256']- )+ payload = jwt_service.verify_jws_token(state)payload['slack_user_id'] = authed_user.get('id')payload['bot_access_token'] = bot_access_tokenpayload['team_id'] = team_id- state = jwt.encode(- payload, config.jwt_secret.get_secret_value(), algorithm='HS256'- )+ state = jwt_service.create_jws_token(payload)# Redirect into keycloakscope = quote('openid email profile offline_access')@@ -158,6 +151,7 @@ async def keycloak_callback(code: str = '',state: str = '',error: str = '',+ jwt_service: JwtService = jwt_service_dependency,):if not code or error:logger.warning(@@ -174,17 +168,7 @@ async def keycloak_callback(status_code=400,)- if not config.jwt_secret:- logger.error('problem_retrieving_keycloak_tokens JWT not configured.')- return _html_response(- title='Error',- description=html.escape('JWT not configured'),- status_code=500,- )-- payload: dict[str, str] = jwt.decode(- state, config.jwt_secret.get_secret_value(), algorithms=['HS256']- )+ payload: dict[str, str] = jwt_service.verify_jws_token(state)slack_user_id = payload['slack_user_id']bot_access_token: str | None = payload['bot_access_token']team_id = payload['team_id']diff --git a/enterprise/storage/encrypt_utils.py b/enterprise/storage/encrypt_utils.pyindex 38bb570e16..185bf19289 100644--- a/enterprise/storage/encrypt_utils.py+++ b/enterprise/storage/encrypt_utils.py@@ -6,7 +6,6 @@ from typing import Anyfrom cryptography.fernet import Fernet, InvalidTokenfrom pydantic import BaseModel, SecretStr-from server.config import get_configfrom sqlalchemy import String, TypeDecoratorfrom sqlalchemy.engine.interfaces import Dialect@@ -14,53 +13,14 @@ _jwt_service = None_fernet = None-def encrypt_model(encrypt_keys: list, model_instance) -> dict:- return encrypt_kwargs(encrypt_keys, model_to_kwargs(model_instance))---def decrypt_model(decrypt_keys: list, model_instance) -> dict:- return decrypt_kwargs(decrypt_keys, model_to_kwargs(model_instance))---def encrypt_kwargs(encrypt_keys: list, kwargs: dict) -> dict:- for key, value in kwargs.items():- if value is None:- continue-- if isinstance(value, dict):- encrypt_kwargs(encrypt_keys, value)- continue-- if key in encrypt_keys:- value = encrypt_value(value)- kwargs[key] = value- return kwargs---def decrypt_kwargs(encrypt_keys: list, kwargs: dict) -> dict:- for key, value in kwargs.items():- try:- if value is None:- continue- if key in encrypt_keys:- value = decrypt_value(value)- kwargs[key] = value- except binascii.Error:- pass # Key is in legacy format...- return kwargs--def encrypt_value(value: str | SecretStr) -> str:- return get_jwt_service().create_jwe_token(- {'v': value.get_secret_value() if isinstance(value, SecretStr) else value}- )+ raw = value.get_secret_value() if isinstance(value, SecretStr) else value+ return get_jwt_service().encrypt_value(raw)def decrypt_value(value: str | SecretStr) -> str:- token = get_jwt_service().decrypt_jwe_token(- value.get_secret_value() if isinstance(value, SecretStr) else value- )- return token['v']+ raw = value.get_secret_value() if isinstance(value, SecretStr) else value+ return get_jwt_service().decrypt_value(raw)def get_jwt_service():@@ -102,20 +62,6 @@ def decrypt_legacy_value(value: str | SecretStr) -> str:return get_fernet().decrypt(b64decode(value.encode())).decode()-def encrypt_legacy_model(encrypt_keys: list, model_instance) -> dict:- return encrypt_legacy_kwargs(encrypt_keys, model_to_kwargs(model_instance))---def encrypt_legacy_kwargs(encrypt_keys: list, kwargs: dict) -> dict:- for key, value in kwargs.items():- if value is None:- continue- if key in encrypt_keys:- value = encrypt_legacy_value(value)- kwargs[key] = value- return kwargs--def encrypt_legacy_value(value: str | SecretStr) -> str:if isinstance(value, SecretStr):return b64encode(@@ -128,8 +74,10 @@ def encrypt_legacy_value(value: str | SecretStr) -> str:def get_fernet():global _fernetif _fernet is None:- jwt_secret = get_config().jwt_secret.get_secret_value()- fernet_key = b64encode(hashlib.sha256(jwt_secret.encode()).digest())+ jwt_svc = get_jwt_service()+ default_key = jwt_svc.get_key(jwt_svc._default_key_id)+ secret = default_key.key.get_secret_value()+ fernet_key = b64encode(hashlib.sha256(secret.encode()).digest())_fernet = Fernet(fernet_key)return _fernetdiff --git a/enterprise/storage/saas_secrets_store.py b/enterprise/storage/saas_secrets_store.pyindex 6856b9fd05..af213f4019 100644--- a/enterprise/storage/saas_secrets_store.py+++ b/enterprise/storage/saas_secrets_store.py@@ -1,10 +1,7 @@from __future__ import annotations-import hashlib-from base64 import b64decode, b64encode-from dataclasses import dataclass+from dataclasses import dataclass, field-from cryptography.fernet import Fernetfrom sqlalchemy import delete, selectfrom storage.database import a_session_makerfrom storage.stored_custom_secrets import StoredCustomSecrets@@ -12,14 +9,14 @@ from storage.user_store import UserStorefrom openhands.app_server.secrets.secrets_models import Secretsfrom openhands.app_server.secrets.secrets_store import SecretsStore+from openhands.app_server.services.jwt_service import JwtServicefrom openhands.app_server.utils.logger import openhands_logger as logger-from openhands.core.config.openhands_config import OpenHandsConfig@dataclassclass SaasSecretsStore(SecretsStore):user_id: str- config: OpenHandsConfig+ _jwt_svc: JwtService = field(repr=False)async def load(self) -> Secrets | None:if not self.user_id:@@ -98,7 +95,6 @@ class SaasSecretsStore(SecretsStore):await session.commit()def _decrypt_kwargs(self, kwargs: dict):- fernet = self._fernet()for key, value in kwargs.items():if isinstance(value, dict):self._decrypt_kwargs(value)@@ -107,11 +103,9 @@ class SaasSecretsStore(SecretsStore):if value is None:kwargs[key] = valueelse:- value = fernet.decrypt(b64decode(value.encode())).decode()- kwargs[key] = value+ kwargs[key] = self._jwt_svc.decrypt_value(value)def _encrypt_kwargs(self, kwargs: dict):- fernet = self._fernet()for key, value in kwargs.items():if isinstance(value, dict):self._encrypt_kwargs(value)@@ -120,21 +114,15 @@ class SaasSecretsStore(SecretsStore):if value is None:kwargs[key] = valueelse:- encrypted_value = b64encode(fernet.encrypt(value.encode())).decode()- kwargs[key] = encrypted_value-- def _fernet(self):- if not self.config.jwt_secret:- raise Exception('config.jwt_secret must be set')- jwt_secret = self.config.jwt_secret.get_secret_value()- fernet_key = b64encode(hashlib.sha256(jwt_secret.encode()).digest())- return Fernet(fernet_key)+ kwargs[key] = self._jwt_svc.encrypt_value(value)@classmethodasync def get_instance(cls,- config: OpenHandsConfig,+ config: object,user_id: str, # type: ignore[override]) -> SaasSecretsStore:logger.debug(f'saas_secrets_store.get_instance::{user_id}')- return SaasSecretsStore(user_id, config)+ from storage.encrypt_utils import get_jwt_service++ return SaasSecretsStore(user_id, get_jwt_service())diff --git a/enterprise/tests/unit/server/routes/test_github_proxy.py b/enterprise/tests/unit/server/routes/test_github_proxy.pyindex 95f8ef1107..ba7a13127a 100644--- a/enterprise/tests/unit/server/routes/test_github_proxy.py+++ b/enterprise/tests/unit/server/routes/test_github_proxy.py@@ -7,26 +7,32 @@ from fastapi.testclient import TestClientfrom pydantic import SecretStrfrom server.routes.github_proxy import add_github_proxy_routes+from openhands.app_server.services.jwt_service import JwtService+from openhands.app_server.utils.encryption_key import EncryptionKey+++def _make_jwt_service() -> JwtService:+ key = EncryptionKey(+ kid='test', key=SecretStr('test-secret-key-for-testing'), active=True+ )+ return JwtService(keys=[key])+@pytest.fixturedef app_with_github_proxy(monkeypatch):"""Create a FastAPI app with github proxy routes enabled."""- # Enable the github proxy endpointsmonkeypatch.setenv('GITHUB_PROXY_ENDPOINTS', '1')- # Mock the config to have a jwt_secret- mock_config = type(- 'MockConfig', (), {'jwt_secret': SecretStr('test-secret-key-for-testing')}- )()-+ jwt_svc = _make_jwt_service()app = FastAPI()- with patch('server.routes.github_proxy.GITHUB_PROXY_ENDPOINTS', True):- with patch('server.routes.github_proxy.config', mock_config):- add_github_proxy_routes(app)+ with (+ patch('server.routes.github_proxy.GITHUB_PROXY_ENDPOINTS', True),+ patch('storage.encrypt_utils.get_jwt_service', return_value=jwt_svc),+ ):+ add_github_proxy_routes(app)- # Return app and mock_config so we can use the same config in tests- return app, mock_config+ return app, jwt_svcdef test_state_compress_encrypt_and_decrypt_decompress_roundtrip(@@ -39,14 +45,14 @@ def test_state_compress_encrypt_and_decrypt_decompress_roundtrip(This test exercises the actual endpoints to verify the roundtrip works correctly."""- app, mock_config = app_with_github_proxy+ app, jwt_svc = app_with_github_proxyclient = TestClient(app)original_state = 'some-state-value'original_redirect_uri = 'https://example.com/redirect'# Call github_proxy_start endpoint - it should redirect to GitHub with encrypted state- with patch('server.routes.github_proxy.config', mock_config):+ with patch('storage.encrypt_utils.get_jwt_service', return_value=jwt_svc):response = client.get('/github-proxy/test-subdomain/login/oauth/authorize',params={@@ -72,7 +78,7 @@ def test_state_compress_encrypt_and_decrypt_decompress_roundtrip(assert 'github-proxy/callback' in query_params['redirect_uri'][0]# Now simulate GitHub calling back with this encrypted state- with patch('server.routes.github_proxy.config', mock_config):+ with patch('storage.encrypt_utils.get_jwt_service', return_value=jwt_svc):callback_response = client.get('/github-proxy/callback',params={diff --git a/enterprise/tests/unit/test_auth_middleware.py b/enterprise/tests/unit/test_auth_middleware.pyindex cf81456b95..2518fbfa01 100644--- a/enterprise/tests/unit/test_auth_middleware.py+++ b/enterprise/tests/unit/test_auth_middleware.py@@ -1,3 +1,4 @@+from contextlib import contextmanagerfrom unittest.mock import AsyncMock, MagicMock, patchimport pytest@@ -16,6 +17,15 @@ from server.middleware import SetAuthCookieMiddlewarefrom openhands.app_server.user_auth.user_auth import AuthType+@contextmanager+def _mock_jwt_decode(accepted_tos: bool = True):+ """Patch get_jwt_service so verify_jws_token returns a controlled payload."""+ mock_svc = MagicMock()+ mock_svc.verify_jws_token.return_value = {'accepted_tos': accepted_tos}+ with patch('storage.encrypt_utils.get_jwt_service', return_value=mock_svc):+ yield mock_svc++@pytest.fixturedef middleware():return SetAuthCookieMiddleware()@@ -55,14 +65,7 @@ async def test_middleware_with_cookie_no_refresh(middleware, mock_request, mock_response):"""Test middleware when auth cookie is present but no refresh occurred."""- # Create a valid JWT token for testing- with (- patch('server.middleware.jwt.decode') as mock_decode,- patch('server.middleware.config') as mock_config,- ):- mock_decode.return_value = {'accepted_tos': True}- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'-+ with _mock_jwt_decode():mock_request.cookies = {'keycloak_auth': 'test_cookie'}mock_call_next = AsyncMock(return_value=mock_response)@@ -86,14 +89,7 @@ async def test_middleware_with_cookie_and_refresh(middleware, mock_request, mock_response):"""Test middleware when auth cookie is present and refresh occurred."""- # Create a valid JWT token for testing- with (- patch('server.middleware.jwt.decode') as mock_decode,- patch('server.middleware.config') as mock_config,- ):- mock_decode.return_value = {'accepted_tos': True}- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'-+ with _mock_jwt_decode():mock_request.cookies = {'keycloak_auth': 'test_cookie'}mock_call_next = AsyncMock(return_value=mock_response)@@ -101,7 +97,7 @@ async def test_middleware_with_cookie_and_refresh(mock_user_auth.refreshed = Truemock_user_auth.access_token = SecretStr('new_access_token')mock_user_auth.refresh_token = SecretStr('new_refresh_token')- mock_user_auth.accepted_tos = True # Set the accepted_tos property on the mock+ mock_user_auth.accepted_tos = Truemock_user_auth.auth_type = AuthType.COOKIEwith (@@ -135,14 +131,7 @@ def decode_body(body: bytes | memoryview):@pytest.mark.asyncioasync def test_middleware_with_no_auth_provided_error(middleware, mock_request):"""Test middleware when NoCredentialsError is raised."""- # Create a valid JWT token for testing- with (- patch('server.middleware.jwt.decode') as mock_decode,- patch('server.middleware.config') as mock_config,- ):- mock_decode.return_value = {'accepted_tos': True}- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'-+ with _mock_jwt_decode():mock_request.cookies = {'keycloak_auth': 'test_cookie'}mock_call_next = AsyncMock(side_effect=NoCredentialsError())@@ -159,14 +148,7 @@ async def test_middleware_with_no_auth_provided_error(middleware, mock_request):@pytest.mark.asyncioasync def test_middleware_with_expired_auth_cookie(middleware, mock_request):"""Test middleware when ExpiredError is raised due to an expired authentication cookie."""- # Create a valid JWT token for testing- with (- patch('server.middleware.jwt.decode') as mock_decode,- patch('server.middleware.config') as mock_config,- ):- mock_decode.return_value = {'accepted_tos': True}- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'-+ with _mock_jwt_decode():mock_request.cookies = {'keycloak_auth': 'test_cookie'}mock_call_next = AsyncMock(side_effect=ExpiredError('Authentication token has expired')@@ -188,14 +170,7 @@ async def test_middleware_with_expired_auth_cookie(middleware, mock_request):@pytest.mark.asyncioasync def test_middleware_with_cookie_error(middleware, mock_request):"""Test middleware when CookieError is raised."""- # Create a valid JWT token for testing- with (- patch('server.middleware.jwt.decode') as mock_decode,- patch('server.middleware.config') as mock_config,- ):- mock_decode.return_value = {'accepted_tos': True}- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'-+ with _mock_jwt_decode():mock_request.cookies = {'keycloak_auth': 'test_cookie'}mock_call_next = AsyncMock(side_effect=CookieError('Invalid cookie'))@@ -212,14 +187,7 @@ async def test_middleware_with_cookie_error(middleware, mock_request):@pytest.mark.asyncioasync def test_middleware_with_other_auth_error(middleware, mock_request):"""Test middleware when another AuthError is raised."""- # Create a valid JWT token for testing- with (- patch('server.middleware.jwt.decode') as mock_decode,- patch('server.middleware.config') as mock_config,- ):- mock_decode.return_value = {'accepted_tos': True}- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'-+ with _mock_jwt_decode():mock_request.cookies = {'keycloak_auth': 'test_cookie'}mock_call_next = AsyncMock(side_effect=AuthError('General auth error'))@@ -269,14 +237,8 @@ async def test_middleware_ignores_email_resend_path_no_tos_check(mock_request.url.path = '/api/email/resend'mock_call_next = AsyncMock(return_value=mock_response)- with (- patch('server.middleware.jwt.decode') as mock_decode,- patch('server.middleware.config') as mock_config,- ):- # Even with accepted_tos=False, should not raise TosNotAcceptedError- mock_decode.return_value = {'accepted_tos': False}- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'-+ # Even with accepted_tos=False, should not raise TosNotAcceptedError+ with _mock_jwt_decode(accepted_tos=False):# Actresult = await middleware(mock_request, mock_call_next)diff --git a/enterprise/tests/unit/test_auth_routes.py b/enterprise/tests/unit/test_auth_routes.pyindex 41d6e47539..45712319ab 100644--- a/enterprise/tests/unit/test_auth_routes.py+++ b/enterprise/tests/unit/test_auth_routes.py@@ -2,7 +2,6 @@ import base64import jsonfrom unittest.mock import AsyncMock, MagicMock, patch-import jwtimport pytestfrom fastapi import HTTPException, Request, Response, statusfrom fastapi.responses import JSONResponse, RedirectResponse@@ -53,12 +52,17 @@ def mock_response():def test_set_response_cookie(mock_response, mock_request):"""Test setting the auth cookie on a response."""+ from openhands.app_server.services.jwt_service import JwtService+ from openhands.app_server.utils.encryption_key import EncryptionKey++ jwt_svc = JwtService(+ keys=[EncryptionKey(kid='test', key=SecretStr('test_secret'), active=True)]+ )with (- patch('server.routes.auth.config') as mock_config,+ patch('storage.encrypt_utils.get_jwt_service', return_value=jwt_svc),patch('server.utils.url_utils.get_global_config') as get_global_config,):- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'get_global_config.return_value = MagicMock(web_url='https://example.com')set_response_cookie(@@ -81,7 +85,7 @@ def test_set_response_cookie(mock_response, mock_request):assert kwargs['domain'] == 'example.com'# Verify the JWT token contains the correct data- token_data = jwt.decode(kwargs['value'], 'test_secret', algorithms=['HS256'])+ token_data = jwt_svc.verify_jws_token(kwargs['value'])assert token_data['access_token'] == 'test_access_token'assert token_data['refresh_token'] == 'test_refresh_token'assert token_data['accepted_tos'] is Truediff --git a/enterprise/tests/unit/test_saas_secrets_store.py b/enterprise/tests/unit/test_saas_secrets_store.pyindex b62a563c40..ba09758e5e 100644--- a/enterprise/tests/unit/test_saas_secrets_store.py+++ b/enterprise/tests/unit/test_saas_secrets_store.py@@ -10,14 +10,18 @@ from storage.stored_custom_secrets import StoredCustomSecretsfrom openhands.app_server.integrations.provider import CustomSecretfrom openhands.app_server.secrets.secrets_models import Secrets-from openhands.core.config.openhands_config import OpenHandsConfig+from openhands.app_server.services.jwt_service import JwtService+from openhands.app_server.utils.encryption_key import EncryptionKey+++def _make_jwt_service() -> JwtService:+ key = EncryptionKey(kid='test', key=SecretStr('test_secret'), active=True)+ return JwtService(keys=[key])@pytest.fixture-def mock_config():- config = MagicMock(spec=OpenHandsConfig)- config.jwt_secret = SecretStr('test_secret')- return config+def jwt_svc():+ return _make_jwt_service()@pytest.fixture@@ -29,13 +33,13 @@ def mock_user():@pytest.fixture-def secrets_store(async_session_maker, mock_config):+def secrets_store(async_session_maker, jwt_svc):# Inject the test session maker into the store moduleimport storage.saas_secrets_store as store_modulestore_module.a_session_maker = async_session_maker- store = SaasSecretsStore('user-id', mock_config)+ store = SaasSecretsStore('user-id', jwt_svc)# Also add it as an attribute for tests that need direct accessstore.a_session_maker = async_session_makerreturn store@@ -240,12 +244,13 @@ class TestSaasSecretsStore:assert 'other_value' not in loaded_secrets.custom_secrets@pytest.mark.asyncio- async def test_get_instance(self, mock_config):+ async def test_get_instance(self, jwt_svc):# Test the get_instance class method- store = await SaasSecretsStore.get_instance(mock_config, 'test-user-id')+ with patch('storage.encrypt_utils.get_jwt_service', return_value=jwt_svc):+ store = await SaasSecretsStore.get_instance(None, 'test-user-id')assert isinstance(store, SaasSecretsStore)assert store.user_id == 'test-user-id'- assert store.config == mock_config+ assert store._jwt_svc is jwt_svc@pytest.mark.asyncio@patch(diff --git a/enterprise/tests/unit/test_saas_user_auth.py b/enterprise/tests/unit/test_saas_user_auth.pyindex e785167b72..e66349a93a 100644--- a/enterprise/tests/unit/test_saas_user_auth.py+++ b/enterprise/tests/unit/test_saas_user_auth.py@@ -71,9 +71,17 @@ def mock_token_manager():@pytest.fixturedef mock_config():- with patch('server.auth.saas_user_auth.get_config') as mock_get_config:+ from openhands.app_server.services.jwt_service import JwtService+ from openhands.app_server.utils.encryption_key import EncryptionKey++ jwt_svc = JwtService(+ keys=[EncryptionKey(kid='test', key=SecretStr('test_secret'), active=True)]+ )+ with (+ patch('server.auth.saas_user_auth.get_config') as mock_get_config,+ patch('storage.encrypt_utils.get_jwt_service', return_value=jwt_svc),+ ):mock_cfg = mock_get_config.return_value- mock_cfg.jwt_secret.get_secret_value.return_value = 'test_secret'yield mock_cfg@@ -1042,7 +1050,9 @@ class TestOpenHandsApiKey:mock_secrets_store = MagicMock()mock_secrets_store.load = AsyncMock(return_value=mock_stored_secrets)- mock_secrets_store_cls.return_value = mock_secrets_store+ mock_secrets_store_cls.get_instance = AsyncMock(+ return_value=mock_secrets_store+ )mock_get_config.return_value = MagicMock()@@ -1098,7 +1108,9 @@ class TestOpenHandsApiKey:mock_secrets_store = MagicMock()mock_secrets_store.load = AsyncMock(return_value=mock_stored_secrets)- mock_secrets_store_cls.return_value = mock_secrets_store+ mock_secrets_store_cls.get_instance = AsyncMock(+ return_value=mock_secrets_store+ )mock_get_config.return_value = MagicMock()@@ -1146,7 +1158,9 @@ class TestOpenHandsApiKey:mock_secrets_store = MagicMock()mock_secrets_store.load = AsyncMock(return_value=mock_stored_secrets)- mock_secrets_store_cls.return_value = mock_secrets_store+ mock_secrets_store_cls.get_instance = AsyncMock(+ return_value=mock_secrets_store+ )mock_get_config.return_value = MagicMock()diff --git a/enterprise/tests/unit/test_token_manager.py b/enterprise/tests/unit/test_token_manager.pyindex 641b84064b..131889d22c 100644--- a/enterprise/tests/unit/test_token_manager.py+++ b/enterprise/tests/unit/test_token_manager.py@@ -2,21 +2,22 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom keycloak.exceptions import KeycloakConnectionError, KeycloakError+from pydantic import SecretStrfrom server.auth.token_manager import TokenManager-from openhands.core.config.openhands_config import OpenHandsConfig+from openhands.app_server.services.jwt_service import JwtService+from openhands.app_server.utils.encryption_key import EncryptionKey-def mock_config():- return MagicMock(spec=OpenHandsConfig)+def _make_jwt_service(secret: str = 'test_secret') -> JwtService:+ key = EncryptionKey(kid='test', key=SecretStr(secret), active=True)+ return JwtService(keys=[key])@pytest.fixturedef token_manager():- with patch('server.config.get_config') as mock_get_config:- mock_config = mock_get_config.return_value- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'+ jwt_svc = _make_jwt_service()+ with patch('storage.encrypt_utils.get_jwt_service', return_value=jwt_svc):return TokenManager(external=False)diff --git a/enterprise/tests/unit/test_token_manager_extended.py b/enterprise/tests/unit/test_token_manager_extended.pyindex 542b17eb70..62f083b879 100644--- a/enterprise/tests/unit/test_token_manager_extended.py+++ b/enterprise/tests/unit/test_token_manager_extended.py@@ -1,41 +1,26 @@from unittest.mock import AsyncMock, MagicMock, patchimport pytest-from server.auth.token_manager import TokenManager, create_encryption_utility+from pydantic import SecretStr+from server.auth.token_manager import TokenManagerfrom openhands.app_server.integrations.service_types import ProviderType+from openhands.app_server.services.jwt_service import JwtService+from openhands.app_server.utils.encryption_key import EncryptionKey+++def _make_jwt_service(secret: str = 'test_secret') -> JwtService:+ key = EncryptionKey(kid='test', key=SecretStr(secret), active=True)+ return JwtService(keys=[key])@pytest.fixturedef token_manager():- with patch('server.config.get_config') as mock_get_config:- mock_config = mock_get_config.return_value- mock_config.jwt_secret.get_secret_value.return_value = 'test_secret'+ jwt_svc = _make_jwt_service()+ with patch('storage.encrypt_utils.get_jwt_service', return_value=jwt_svc):return TokenManager(external=False)-def test_create_encryption_utility():- """Test the encryption utility creation and functionality."""- secret_key = b'test_secret_key_that_is_32_bytes_lng'- encrypt_payload, decrypt_payload, encrypt_text, decrypt_text = (- create_encryption_utility(secret_key)- )-- # Test text encryption/decryption- original_text = 'This is a test message'- encrypted = encrypt_text(original_text)- decrypted = decrypt_text(encrypted)- assert decrypted == original_text- assert encrypted != original_text-- # Test payload encryption/decryption- original_payload = {'key1': 'value1', 'key2': 123, 'nested': {'inner': 'value'}}- encrypted = encrypt_payload(original_payload)- decrypted = decrypt_payload(encrypted)- assert decrypted == original_payload- assert encrypted != original_payload--@pytest.mark.asyncioasync def test_get_keycloak_tokens_success(token_manager):"""Test successful retrieval of Keycloak tokens."""diff --git a/openhands/app_server/services/jwt_service.py b/openhands/app_server/services/jwt_service.pyindex 42ef783c0d..707f5542e4 100644--- a/openhands/app_server/services/jwt_service.py+++ b/openhands/app_server/services/jwt_service.py@@ -1,10 +1,14 @@+import binasciiimport hashlibimport json+import logging+from base64 import b64decode, b64encodefrom datetime import timedeltafrom pathlib import Pathfrom typing import Any, AsyncGeneratorimport jwt+from cryptography.fernet import Fernet, InvalidTokenfrom fastapi import Requestfrom jwcrypto import jwe as jwcrypto_jwefrom jwcrypto import jwk@@ -17,6 +21,8 @@ from openhands.app_server.utils.encryption_key import (get_default_encryption_keys,)+logger = logging.getLogger(__name__)+class JwtService:"""Service for signing/verifying JWS tokens and encrypting/decrypting JWE tokens."""@@ -46,6 +52,13 @@ class JwtService:"""Get the default key ID."""return self._default_key_id+ @property+ def key_ids(self) -> list[str]:+ return list(self._keys)++ def get_key(self, key_id: str) -> EncryptionKey:+ return self._keys[key_id]+def create_jws_token(self,payload: dict[str, Any],@@ -110,7 +123,9 @@ class JwtService:unverified_header = jwt.get_unverified_header(token)key_id = unverified_header.get('kid')if not key_id:- raise ValueError("Token does not contain 'kid' header with key ID")+ # Legacy tokens created before key rotation support+ # don't carry a kid header — fall back to the default key.+ key_id = self._default_key_idexcept jwt.DecodeError:raise ValueError('Invalid JWT token format')@@ -249,6 +264,66 @@ class JwtService:except Exception as e:raise Exception(f'Token decryption failed: {str(e)}')+ # ------------------------------------------------------------------+ # Symmetric encrypt / decrypt helpers (JWE with legacy Fernet fallback)+ # ------------------------------------------------------------------++ def encrypt_value(self, plaintext: str) -> str:+ """Encrypt a plaintext string using JWE.++ New data is always encrypted with JWE. Use :meth:`decrypt_value`+ to decrypt, which also handles legacy Fernet-encrypted data.+ """+ return self.create_jwe_token({'v': plaintext})++ def decrypt_value(self, ciphertext: str) -> str:+ """Decrypt a ciphertext string, trying JWE first then legacy Fernet.++ During the migration from Fernet to JWE, persisted data may be+ encrypted with either scheme. This method transparently handles+ both: it attempts JWE decryption first, and falls back to Fernet+ (trying every known key) if that fails.+ """+ # Try JWE first (modern path)+ try:+ payload = self.decrypt_jwe_token(ciphertext)+ return payload['v']+ except Exception:+ pass++ # Fall back to legacy Fernet decryption+ return self._decrypt_fernet_value(ciphertext)++ def _decrypt_fernet_value(self, ciphertext: str) -> str:+ """Attempt Fernet decryption using every known key.++ The legacy Fernet key is derived as+ ``b64encode(sha256(secret).digest())``, matching the convention+ previously used by enterprise code.++ Some values were base64 encoded after encryption, and some were not,+ so we accommodate both cases.++ Raises ``ValueError`` if no key can decrypt the value.+ """+ last_error: Exception | None = None+ for key in self._keys.values():+ try:+ secret = key.key.get_secret_value()+ fernet_key = b64encode(hashlib.sha256(secret.encode()).digest())+ f = Fernet(fernet_key)+ # There are multiple legacy formats - some cases have base64 encoded+ # after encryption and some have not. We try both+ try:+ return f.decrypt(b64decode(ciphertext.encode())).decode()+ except Exception:+ return f.decrypt(ciphertext.encode()).decode()+ except (InvalidToken, binascii.Error, Exception) as exc:+ last_error = exc+ continue++ raise ValueError('Failed to decrypt value with any known key') from last_error+class JwtServiceInjector(BaseModel, Injector[JwtService]):persistence_dir: Pathdiff --git a/openhands/app_server/settings/settings_router.py b/openhands/app_server/settings/settings_router.pyindex 3422bdca5a..9f796d0c8f 100644--- a/openhands/app_server/settings/settings_router.py+++ b/openhands/app_server/settings/settings_router.py@@ -49,7 +49,6 @@ from openhands.sdk.settings import (OpenHandsAgentSettings,export_agent_settings_schema,)-from openhands.server.shared import configLITE_LLM_API_URL = os.environ.get('LITE_LLM_API_URL', 'https://llm-proxy.app.all-hands.dev'@@ -237,20 +236,6 @@ async def store_settings(if settings.disabled_skills is None:settings.disabled_skills = existing_settings.disabled_skills- # Update git configuration with new settings- git_config_updated = False- if settings.git_user_name is not None:- config.git_user_name = settings.git_user_name- git_config_updated = True- if settings.git_user_email is not None:- config.git_user_email = settings.git_user_email- git_config_updated = True-- if git_config_updated:- logger.info(- f'Updated global git configuration: name={config.git_user_name}, email={config.git_user_email}'- )-await settings_store.store(settings)return JSONResponse(status_code=status.HTTP_200_OK,diff --git a/openhands/app_server/utils/encryption_key.py b/openhands/app_server/utils/encryption_key.pyindex 62224e1da1..14201b6579 100644--- a/openhands/app_server/utils/encryption_key.py+++ b/openhands/app_server/utils/encryption_key.py@@ -1,6 +1,6 @@+import datetimeimport hashlibimport os-from datetime import datetimefrom pathlib import Pathfrom typing import Any@@ -17,7 +17,7 @@ class EncryptionKey(BaseModel):key: SecretStractive: bool = Truenotes: str | None = None- created_at: datetime = Field(default_factory=utc_now)+ created_at: datetime.datetime = Field(default_factory=utc_now)@field_serializer('key')def serialize_key(self, key: SecretStr, info: Any):@@ -28,18 +28,21 @@ class EncryptionKey(BaseModel):def get_default_encryption_keys(workspace_dir: Path) -> list[EncryptionKey]:- """Generate default encryption keys."""- master_key = os.getenv('JWT_SECRET')- if master_key:+ """Generate default encryption keys obtain these from previously saved values+ and environment variables."""+ encryption_keys = []++ jwt_secret = os.getenv('JWT_SECRET')+ if jwt_secret:# Derive a deterministic key ID from the secret itself.# This ensures all pods using the same JWT_SECRET get the same key ID,# which is critical for multi-pod deployments where tokens may be# created by one pod and verified by another.- key_id = base62.encodebytes(hashlib.sha256(master_key.encode()).digest())+ key_id = base62.encodebytes(hashlib.sha256(jwt_secret.encode()).digest())return [EncryptionKey(id=key_id,- key=SecretStr(master_key),+ key=SecretStr(jwt_secret),active=True,notes='jwt secret master key',)@@ -49,6 +52,24 @@ def get_default_encryption_keys(workspace_dir: Path) -> list[EncryptionKey]:type_adapter = TypeAdapter(list[EncryptionKey])if key_file.exists():encryption_keys = type_adapter.validate_json(key_file.read_text())++ # Fallback to JWTSecret...+ jwt_secret_file = workspace_dir / '.jwt_secret'+ if jwt_secret_file.exists():+ jwt_secret = jwt_secret_file.read_text().strip()+ encryption_keys.append(+ EncryptionKey(+ id=base62.encodebytes(hashlib.sha256(jwt_secret.encode()).digest()),+ key=SecretStr(jwt_secret),+ active=True,+ notes='jwt secret master key',+ created_at=datetime.datetime.fromtimestamp(+ jwt_secret_file.stat().st_mtime, tz=datetime.UTC+ ),+ )+ )++ if encryption_keys:return encryption_keysencryption_keys = [diff --git a/tests/unit/app_server/test_encryption_key.py b/tests/unit/app_server/test_encryption_key.pynew file mode 100644index 0000000000..a6b249dca6--- /dev/null+++ b/tests/unit/app_server/test_encryption_key.py@@ -0,0 +1,300 @@+"""Tests for encryption key utilities.++This module tests the get_default_encryption_keys function which handles:+- Loading keys from JWT_SECRET environment variable+- Loading keys from .keys JSON file+- Loading keys from legacy .jwt_secret file+- Generating new keys when none exist+"""++import datetime+import hashlib+import os+from unittest.mock import patch++import base62+import pytest+from pydantic import SecretStr, TypeAdapter++from openhands.app_server.utils.encryption_key import (+ EncryptionKey,+ get_default_encryption_keys,+)+++class TestGetDefaultEncryptionKeys:+ """Test cases for get_default_encryption_keys function."""++ @pytest.fixture+ def temp_workspace(self, tmp_path):+ """Create a temporary workspace directory."""+ return tmp_path++ @pytest.fixture+ def clear_jwt_secret_env(self):+ """Ensure JWT_SECRET env var is not set during tests."""+ original = os.environ.pop('JWT_SECRET', None)+ yield+ if original is not None:+ os.environ['JWT_SECRET'] = original++ def test_jwt_secret_env_var_takes_priority(self, temp_workspace):+ """When JWT_SECRET env var is set, it takes priority over files."""+ jwt_secret = 'my-super-secret-key-from-env'+ expected_key_id = base62.encodebytes(+ hashlib.sha256(jwt_secret.encode()).digest()+ )++ with patch.dict(os.environ, {'JWT_SECRET': jwt_secret}):+ keys = get_default_encryption_keys(temp_workspace)++ assert len(keys) == 1+ assert keys[0].id == expected_key_id+ assert keys[0].key.get_secret_value() == jwt_secret+ assert keys[0].active is True+ assert keys[0].notes == 'jwt secret master key'++ def test_jwt_secret_env_var_ignores_files(self, temp_workspace):+ """When JWT_SECRET env var is set, .keys and .jwt_secret files are ignored."""+ # Create both files+ keys_file = temp_workspace / '.keys'+ jwt_secret_file = temp_workspace / '.jwt_secret'++ file_key = EncryptionKey(+ id='file-key-id',+ key=SecretStr('file-secret'),+ active=True,+ notes='from file',+ )+ type_adapter = TypeAdapter(list[EncryptionKey])+ keys_file.write_bytes(+ type_adapter.dump_json([file_key], context={'expose_secrets': True})+ )+ jwt_secret_file.write_text('legacy-jwt-secret')++ env_secret = 'env-var-secret'+ with patch.dict(os.environ, {'JWT_SECRET': env_secret}):+ keys = get_default_encryption_keys(temp_workspace)++ # Should only have the env var key, not the file keys+ assert len(keys) == 1+ assert keys[0].key.get_secret_value() == env_secret++ def test_loads_keys_from_keys_file(self, temp_workspace, clear_jwt_secret_env):+ """When .keys file exists, loads keys from it."""+ keys_file = temp_workspace / '.keys'++ stored_keys = [+ EncryptionKey(+ id='key-1',+ key=SecretStr('secret-1'),+ active=True,+ notes='first key',+ created_at=datetime.datetime(2023, 1, 1, tzinfo=datetime.UTC),+ ),+ EncryptionKey(+ id='key-2',+ key=SecretStr('secret-2'),+ active=False,+ notes='rotated key',+ created_at=datetime.datetime(2023, 6, 1, tzinfo=datetime.UTC),+ ),+ ]+ type_adapter = TypeAdapter(list[EncryptionKey])+ keys_file.write_bytes(+ type_adapter.dump_json(stored_keys, context={'expose_secrets': True})+ )++ keys = get_default_encryption_keys(temp_workspace)++ assert len(keys) == 2+ assert keys[0].id == 'key-1'+ assert keys[0].key.get_secret_value() == 'secret-1'+ assert keys[0].active is True+ assert keys[1].id == 'key-2'+ assert keys[1].key.get_secret_value() == 'secret-2'+ assert keys[1].active is False++ def test_loads_keys_from_jwt_secret_file(+ self, temp_workspace, clear_jwt_secret_env+ ):+ """When only .jwt_secret file exists, loads key from it."""+ jwt_secret_file = temp_workspace / '.jwt_secret'+ jwt_secret = 'legacy-jwt-secret-value'+ jwt_secret_file.write_text(jwt_secret)++ expected_key_id = base62.encodebytes(+ hashlib.sha256(jwt_secret.encode()).digest()+ )++ keys = get_default_encryption_keys(temp_workspace)++ assert len(keys) == 1+ assert keys[0].id == expected_key_id+ assert keys[0].key.get_secret_value() == jwt_secret+ assert keys[0].active is True+ assert keys[0].notes == 'jwt secret master key'++ def test_jwt_secret_file_strips_whitespace(+ self, temp_workspace, clear_jwt_secret_env+ ):+ """The .jwt_secret file content should be stripped of whitespace."""+ jwt_secret_file = temp_workspace / '.jwt_secret'+ jwt_secret = 'secret-with-whitespace'+ jwt_secret_file.write_text(f' {jwt_secret} \n')++ keys = get_default_encryption_keys(temp_workspace)++ assert keys[0].key.get_secret_value() == jwt_secret++ def test_combines_keys_and_jwt_secret_files(+ self, temp_workspace, clear_jwt_secret_env+ ):+ """When both .keys and .jwt_secret exist, combines keys from both."""+ keys_file = temp_workspace / '.keys'+ jwt_secret_file = temp_workspace / '.jwt_secret'++ stored_key = EncryptionKey(+ id='keys-file-key',+ key=SecretStr('keys-file-secret'),+ active=True,+ notes='from .keys file',+ )+ type_adapter = TypeAdapter(list[EncryptionKey])+ keys_file.write_bytes(+ type_adapter.dump_json([stored_key], context={'expose_secrets': True})+ )++ jwt_secret = 'jwt-secret-file-value'+ jwt_secret_file.write_text(jwt_secret)++ keys = get_default_encryption_keys(temp_workspace)++ # Should have both keys+ assert len(keys) == 2+ assert keys[0].id == 'keys-file-key'+ assert keys[0].key.get_secret_value() == 'keys-file-secret'+ # Second key is from .jwt_secret+ assert keys[1].key.get_secret_value() == jwt_secret++ def test_generates_new_key_when_none_exist(+ self, temp_workspace, clear_jwt_secret_env+ ):+ """When no keys exist, generates a new one and persists it."""+ keys_file = temp_workspace / '.keys'+ assert not keys_file.exists()++ keys = get_default_encryption_keys(temp_workspace)++ # Should generate one key+ assert len(keys) == 1+ assert keys[0].active is True+ assert keys[0].notes == 'generated master key'+ # Key should be non-empty+ assert len(keys[0].key.get_secret_value()) > 0++ # Should persist to .keys file+ assert keys_file.exists()++ def test_generated_key_is_persisted_correctly(+ self, temp_workspace, clear_jwt_secret_env+ ):+ """Generated keys should be readable on subsequent calls."""+ # First call generates key+ keys1 = get_default_encryption_keys(temp_workspace)++ # Second call should load the same key+ keys2 = get_default_encryption_keys(temp_workspace)++ assert len(keys1) == 1+ assert len(keys2) == 1+ assert keys1[0].id == keys2[0].id+ assert keys1[0].key.get_secret_value() == keys2[0].key.get_secret_value()++ def test_jwt_secret_file_created_at_uses_file_mtime(+ self, temp_workspace, clear_jwt_secret_env+ ):+ """The created_at for .jwt_secret key should use the file's mtime."""+ jwt_secret_file = temp_workspace / '.jwt_secret'+ jwt_secret_file.write_text('test-secret')++ # Get the file's modification time+ file_mtime = jwt_secret_file.stat().st_mtime+ expected_created_at = datetime.datetime.fromtimestamp(+ file_mtime, tz=datetime.UTC+ )++ keys = get_default_encryption_keys(temp_workspace)++ assert keys[0].created_at == expected_created_at++ def test_deterministic_key_id_from_jwt_secret_env(self, temp_workspace):+ """Key ID derived from JWT_SECRET should be deterministic."""+ jwt_secret = 'deterministic-secret'+ expected_key_id = base62.encodebytes(+ hashlib.sha256(jwt_secret.encode()).digest()+ )++ with patch.dict(os.environ, {'JWT_SECRET': jwt_secret}):+ keys1 = get_default_encryption_keys(temp_workspace)+ keys2 = get_default_encryption_keys(temp_workspace)++ assert keys1[0].id == keys2[0].id == expected_key_id++ def test_deterministic_key_id_from_jwt_secret_file(+ self, temp_workspace, clear_jwt_secret_env+ ):+ """Key ID derived from .jwt_secret file should be deterministic."""+ jwt_secret = 'file-based-secret'+ jwt_secret_file = temp_workspace / '.jwt_secret'+ jwt_secret_file.write_text(jwt_secret)++ expected_key_id = base62.encodebytes(+ hashlib.sha256(jwt_secret.encode()).digest()+ )++ keys = get_default_encryption_keys(temp_workspace)++ assert keys[0].id == expected_key_id+++class TestEncryptionKey:+ """Test cases for EncryptionKey model."""++ def test_default_id_is_generated(self):+ """EncryptionKey generates a random ID by default."""+ key1 = EncryptionKey(key=SecretStr('secret1'))+ key2 = EncryptionKey(key=SecretStr('secret2'))++ # IDs should be non-empty and different+ assert key1.id+ assert key2.id+ assert key1.id != key2.id++ def test_default_active_is_true(self):+ """EncryptionKey defaults to active=True."""+ key = EncryptionKey(key=SecretStr('secret'))+ assert key.active is True++ def test_serialize_key_masks_by_default(self):+ """Key serialization masks the secret by default."""+ key = EncryptionKey(key=SecretStr('super-secret'))+ serialized = key.model_dump()++ # The key should be masked+ assert serialized['key'] == '**********'++ def test_serialize_key_exposes_with_context(self):+ """Key serialization exposes secret when context allows."""+ key = EncryptionKey(key=SecretStr('super-secret'))+ serialized = key.model_dump(context={'expose_secrets': True})++ assert serialized['key'] == 'super-secret'++ def test_created_at_defaults_to_now(self):+ """EncryptionKey created_at defaults to current time."""+ before = datetime.datetime.now(datetime.UTC)+ key = EncryptionKey(key=SecretStr('secret'))+ after = datetime.datetime.now(datetime.UTC)++ assert before <= key.created_at <= afterdiff --git a/tests/unit/app_server/test_jwt_service.py b/tests/unit/app_server/test_jwt_service.pyindex 2c4409760f..45b4d71d50 100644--- a/tests/unit/app_server/test_jwt_service.py+++ b/tests/unit/app_server/test_jwt_service.py@@ -3,16 +3,20 @@This module tests the JWT service functionality including:- JWS token creation and verification (sign/verify round trip)- JWE token creation and decryption (encrypt/decrypt round trip)+- Symmetric encrypt/decrypt helpers (JWE + legacy Fernet fallback)- Key management and rotation- Error handling and edge cases"""+import hashlibimport json+from base64 import b64encodefrom datetime import datetime, timedeltafrom unittest.mock import patchimport jwtimport pytest+from cryptography.fernet import Fernetfrom jwcrypto import jwe as jwcrypto_jwefrom jwcrypto import jwkfrom pydantic import SecretStr@@ -157,15 +161,25 @@ class TestJwtService:with pytest.raises(ValueError, match='Invalid JWT token format'):jwt_service.verify_jws_token('invalid.token')- def test_jws_token_verification_no_kid_header(self, jwt_service):- """Test JWS token verification fails when token has no kid header."""- # Create a token without kid header using PyJWT directly+ def test_jws_token_verification_no_kid_header_falls_back_to_default_key(+ self, jwt_service, sample_keys+ ):+ """Test JWS token verification uses default key when token has no kid header."""+ # Create a token without kid header using PyJWT directly,+ # signed with the default key's secret (key2 is newest active).+ default_secret = sample_keys[1].key.get_secret_value()payload = {'user_id': '123'}- token = jwt.encode(payload, 'some_secret', algorithm='HS256')+ token = jwt.encode(payload, default_secret, algorithm='HS256')- with pytest.raises(- ValueError, match="Token does not contain 'kid' header with key ID"- ):+ decoded = jwt_service.verify_jws_token(token)+ assert decoded['user_id'] == '123'++ def test_jws_token_verification_no_kid_header_wrong_secret(self, jwt_service):+ """Test JWS verification fails for no-kid token signed with wrong secret."""+ payload = {'user_id': '123'}+ token = jwt.encode(payload, 'totally_wrong_secret', algorithm='HS256')++ with pytest.raises(jwt.InvalidTokenError, match='Token verification failed'):jwt_service.verify_jws_token(token)def test_jws_token_verification_wrong_signature(self, jwt_service):@@ -514,3 +528,73 @@ class TestJwtService:assert unicode_decrypted['description'] == 'Testing with émojis 🚀'assert unicode_decrypted['chinese'] == 'ä½ å¥½ä¸–ç•Œ'assert unicode_decrypted['iat'] == 1704067200+++class TestEncryptDecryptValue:+ """Tests for JwtService.encrypt_value / decrypt_value (JWE + Fernet fallback)."""++ @pytest.fixture+ def sample_keys(self):+ return [+ EncryptionKey(+ id='key1',+ key=SecretStr('test_secret_key_1'),+ active=True,+ created_at=datetime(2023, 1, 1, tzinfo=None),+ ),+ EncryptionKey(+ id='key2',+ key=SecretStr('test_secret_key_2'),+ active=True,+ created_at=datetime(2023, 1, 2, tzinfo=None),+ ),+ ]++ @pytest.fixture+ def jwt_service(self, sample_keys):+ return JwtService(sample_keys)++ def test_encrypt_decrypt_round_trip(self, jwt_service):+ """encrypt_value then decrypt_value returns the original text."""+ plaintext = 'super-secret-api-key-12345'+ ciphertext = jwt_service.encrypt_value(plaintext)+ assert jwt_service.decrypt_value(ciphertext) == plaintext++ def test_encrypt_decrypt_unicode(self, jwt_service):+ plaintext = 'Héllo Wörld 🔑'+ ciphertext = jwt_service.encrypt_value(plaintext)+ assert jwt_service.decrypt_value(ciphertext) == plaintext++ def test_decrypt_legacy_fernet_value(self, jwt_service, sample_keys):+ """decrypt_value handles data encrypted with the legacy Fernet scheme."""+ secret = sample_keys[1].key.get_secret_value() # key2 (default)+ fernet_key = b64encode(hashlib.sha256(secret.encode()).digest())+ f = Fernet(fernet_key)+ plaintext = 'legacy-encrypted-token'+ # Fernet.encrypt() returns base64-encoded bytes, decode to string+ # (no extra b64encode - that was the bug!)+ legacy_ciphertext = f.encrypt(plaintext.encode()).decode()++ assert jwt_service.decrypt_value(legacy_ciphertext) == plaintext++ def test_decrypt_legacy_fernet_non_default_key(self, jwt_service, sample_keys):+ """decrypt_value falls through to a non-default key for Fernet."""+ secret = sample_keys[0].key.get_secret_value() # key1 (not default)+ fernet_key = b64encode(hashlib.sha256(secret.encode()).digest())+ f = Fernet(fernet_key)+ plaintext = 'old-key-data'+ # Fernet.encrypt() returns base64-encoded bytes, decode to string+ # (no extra b64encode - that was the bug!)+ legacy_ciphertext = f.encrypt(plaintext.encode()).decode()++ assert jwt_service.decrypt_value(legacy_ciphertext) == plaintext++ def test_decrypt_value_fails_for_garbage(self, jwt_service):+ with pytest.raises(ValueError, match='Failed to decrypt value'):+ jwt_service.decrypt_value('not-valid-ciphertext-at-all')++ def test_encrypt_value_is_jwe(self, jwt_service):+ """encrypt_value produces a JWE token (5-part compact serialization)."""+ ciphertext = jwt_service.encrypt_value('hello')+ # JWE compact serialization has exactly 4 dots+ assert ciphertext.count('.') == 4