Skip to content

🙌 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.py
index 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 Environment
from server.auth.constants import GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY
from server.auth.token_manager import TokenManager
-from server.config import get_config
from storage.org_store import OrgStore
from storage.proactive_conversation_store import ProactiveConversationStore
from storage.saas_secrets_store import SaasSecretsStore
@@ -135,7 +134,9 @@ class GithubIssue(ResolverViewInterface):
return user_instructions, conversation_instructions
async 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 None
diff --git a/enterprise/integrations/gitlab/gitlab_view.py b/enterprise/integrations/gitlab/gitlab_view.py
index 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 Environment
from server.auth.token_manager import TokenManager
-from server.config import get_config
from storage.saas_secrets_store import SaasSecretsStore
from openhands.agent_server.models import SendMessageRequest
@@ -97,7 +96,9 @@ class GitlabIssue(ResolverViewInterface):
return user_instructions, conversation_instructions
async 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 None
diff --git a/enterprise/integrations/slack/slack_manager.py b/enterprise/integrations/slack/slack_manager.py
index 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 jwt
from integrations.manager import Manager
from integrations.models import Message, SourceType
from 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 UserAuth
from openhands.app_server.utils.logger import openhands_logger as logger
-from openhands.server.shared import config, server_config
+from openhands.server.shared import server_config
from 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.py
index 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_store
if 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_store
return 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.py
index dd25c09b3a..74db1c60eb 100644
--- a/enterprise/server/auth/token_manager.py
+++ b/enterprise/server/auth/token_manager.py
@@ -1,14 +1,11 @@
import asyncio
import base64
-import hashlib
import json
import time
-from base64 import b64encode
from urllib.parse import parse_qs
import httpx
import jwt
-from cryptography.fernet import Fernet
from jwt.exceptions import DecodeError
from 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_token
except 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.py
index 6313705e8f..d550a088ee 100644
--- a/enterprise/server/middleware.py
+++ b/enterprise/server/middleware.py
@@ -3,7 +3,6 @@ from typing import Callable, cast
import jwt
from fastapi import Request, Response, status
from fastapi.responses import JSONResponse
-from pydantic import SecretStr
from server.auth.auth_error import (
AuthError,
EmailNotVerifiedError,
@@ -17,7 +16,6 @@ from server.utils.url_utils import get_cookie_domain, get_cookie_samesite
from openhands.app_server.user_auth.user_auth import AuthType, UserAuth, get_user_auth
from openhands.app_server.utils.logger import openhands_logger as logger
-from openhands.server.shared import config
class 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 errors
logger.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.py
index c861caa36a..d7fac4798a 100644
--- a/enterprise/server/routes/auth.py
+++ b/enterprise/server/routes/auth.py
@@ -2,7 +2,7 @@ import base64
import json
import uuid
import warnings
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
from types import MappingProxyType
from typing import Annotated, Optional, cast
from 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_token
from server.constants import (
DEPLOYMENT_MODE,
IS_FEATURE_ENV,
@@ -56,7 +55,6 @@ from openhands.app_server.integrations.service_types import ProviderType, TokenR
from openhands.app_server.user_auth import get_access_token
from openhands.app_server.user_auth.user_auth import get_user_auth
from openhands.app_server.utils.logger import openhands_logger as logger
-from openhands.server.shared import config
with 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 token
domain = get_cookie_domain()
diff --git a/enterprise/server/routes/github_proxy.py b/enterprise/server/routes/github_proxy.py
index 96091ddcae..e75833940c 100644
--- a/enterprise/server/routes/github_proxy.py
+++ b/enterprise/server/routes/github_proxy.py
@@ -1,4 +1,3 @@
-import hashlib
import json
import os
import zlib
@@ -6,13 +5,11 @@ from base64 import b64decode, b64encode
from urllib.parse import parse_qs, urlencode, urlparse
import httpx
-from cryptography.fernet import Fernet
from fastapi import FastAPI, Request, Response
from fastapi.responses import RedirectResponse
from server.logger import logger
from openhands.app_server.utils.http_session import httpx_verify_option
-from openhands.server.shared import config
GITHUB_PROXY_ENDPOINTS = bool(os.environ.get('GITHUB_PROXY_ENDPOINTS'))
@@ -39,11 +36,9 @@ def add_github_proxy_routes(app: FastAPI):
return
def _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.py
index 7ab4eaadba..c483f1e4ce 100644
--- a/enterprise/server/routes/integration/slack.py
+++ b/enterprise/server/routes/integration/slack.py
@@ -2,7 +2,6 @@ import html
import json
from urllib.parse import quote
-import jwt
from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
from fastapi.responses import (
HTMLResponse,
@@ -40,11 +39,12 @@ from storage.slack_team_store import SlackTeamStore
from storage.slack_user import SlackUser
from storage.user_store import UserStore
+from openhands.app_server.config import depends_jwt_service
from openhands.app_server.integrations.service_types import (
ProviderTimeoutError,
ProviderType,
)
-from openhands.server.shared import config
+from openhands.app_server.services.jwt_service import JwtService
signature_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 oauth
payload = {}
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_token
payload['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 keycloak
scope = 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.py
index 38bb570e16..185bf19289 100644
--- a/enterprise/storage/encrypt_utils.py
+++ b/enterprise/storage/encrypt_utils.py
@@ -6,7 +6,6 @@ from typing import Any
from cryptography.fernet import Fernet, InvalidToken
from pydantic import BaseModel, SecretStr
-from server.config import get_config
from sqlalchemy import String, TypeDecorator
from 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 _fernet
if _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 _fernet
diff --git a/enterprise/storage/saas_secrets_store.py b/enterprise/storage/saas_secrets_store.py
index 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 Fernet
from sqlalchemy import delete, select
from storage.database import a_session_maker
from storage.stored_custom_secrets import StoredCustomSecrets
@@ -12,14 +9,14 @@ from storage.user_store import UserStore
from openhands.app_server.secrets.secrets_models import Secrets
from openhands.app_server.secrets.secrets_store import SecretsStore
+from openhands.app_server.services.jwt_service import JwtService
from openhands.app_server.utils.logger import openhands_logger as logger
-from openhands.core.config.openhands_config import OpenHandsConfig
@dataclass
class 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] = value
else:
- 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] = value
else:
- 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)
@classmethod
async 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.py
index 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 TestClient
from pydantic import SecretStr
from 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.fixture
def app_with_github_proxy(monkeypatch):
"""Create a FastAPI app with github proxy routes enabled."""
- # Enable the github proxy endpoints
monkeypatch.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_svc
def 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_proxy
client = 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.py
index 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 contextmanager
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
@@ -16,6 +17,15 @@ from server.middleware import SetAuthCookieMiddleware
from 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.fixture
def 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 = True
mock_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 = True
mock_user_auth.auth_type = AuthType.COOKIE
with (
@@ -135,14 +131,7 @@ def decode_body(body: bytes | memoryview):
@pytest.mark.asyncio
async 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.asyncio
async 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.asyncio
async 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.asyncio
async 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):
# Act
result = await middleware(mock_request, mock_call_next)
diff --git a/enterprise/tests/unit/test_auth_routes.py b/enterprise/tests/unit/test_auth_routes.py
index 41d6e47539..45712319ab 100644
--- a/enterprise/tests/unit/test_auth_routes.py
+++ b/enterprise/tests/unit/test_auth_routes.py
@@ -2,7 +2,6 @@ import base64
import json
from unittest.mock import AsyncMock, MagicMock, patch
-import jwt
import pytest
from fastapi import HTTPException, Request, Response, status
from 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 True
diff --git a/enterprise/tests/unit/test_saas_secrets_store.py b/enterprise/tests/unit/test_saas_secrets_store.py
index 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 StoredCustomSecrets
from openhands.app_server.integrations.provider import CustomSecret
from 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 module
import storage.saas_secrets_store as store_module
store_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 access
store.a_session_maker = async_session_maker
return 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.py
index 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.fixture
def 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.py
index 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, patch
import pytest
from keycloak.exceptions import KeycloakConnectionError, KeycloakError
+from pydantic import SecretStr
from 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.fixture
def 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.py
index 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, patch
import pytest
-from server.auth.token_manager import TokenManager, create_encryption_utility
+from pydantic import SecretStr
+from server.auth.token_manager import TokenManager
from 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.fixture
def 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.asyncio
async 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.py
index 42ef783c0d..707f5542e4 100644
--- a/openhands/app_server/services/jwt_service.py
+++ b/openhands/app_server/services/jwt_service.py
@@ -1,10 +1,14 @@
+import binascii
import hashlib
import json
+import logging
+from base64 import b64decode, b64encode
from datetime import timedelta
from pathlib import Path
from typing import Any, AsyncGenerator
import jwt
+from cryptography.fernet import Fernet, InvalidToken
from fastapi import Request
from jwcrypto import jwe as jwcrypto_jwe
from 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_id
except 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: Path
diff --git a/openhands/app_server/settings/settings_router.py b/openhands/app_server/settings/settings_router.py
index 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 config
LITE_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.py
index 62224e1da1..14201b6579 100644
--- a/openhands/app_server/utils/encryption_key.py
+++ b/openhands/app_server/utils/encryption_key.py
@@ -1,6 +1,6 @@
+import datetime
import hashlib
import os
-from datetime import datetime
from pathlib import Path
from typing import Any
@@ -17,7 +17,7 @@ class EncryptionKey(BaseModel):
key: SecretStr
active: bool = True
notes: 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_keys
encryption_keys = [
diff --git a/tests/unit/app_server/test_encryption_key.py b/tests/unit/app_server/test_encryption_key.py
new file mode 100644
index 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 <= after
diff --git a/tests/unit/app_server/test_jwt_service.py b/tests/unit/app_server/test_jwt_service.py
index 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 hashlib
import json
+from base64 import b64encode
from datetime import datetime, timedelta
from unittest.mock import patch
import jwt
import pytest
+from cryptography.fernet import Fernet
from jwcrypto import jwe as jwcrypto_jwe
from jwcrypto import jwk
from 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