Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

refactor(auth): validate identities and clarify API key management (#6752)

MaojiaSheng05c516dc605c
diff --git a/crates/ov_cli/src/commands/admin.rs b/crates/ov_cli/src/commands/admin.rs
index 201a1191f..9022300da 100644
--- a/crates/ov_cli/src/commands/admin.rs
+++ b/crates/ov_cli/src/commands/admin.rs
@@ -467,7 +467,7 @@ fn mask_plaintext_api_keys(value: &mut Value) -> bool {
}
}
-/// Match `openviking/server/api_keys/new.py:mask_api_key` so CLI and API output look the same.
+/// Match `openviking/server/api_keys/key_mgr.py:mask_api_key` so CLI and API output look the same.
fn mask_api_key(api_key: &str) -> String {
let parts: Vec<&str> = api_key.split('.').collect();
if api_key.is_empty() || parts.len() != 3 {
diff --git a/docs/en/api/08-admin.md b/docs/en/api/08-admin.md
index 5687b2dd6..81c19faa1 100644
--- a/docs/en/api/08-admin.md
+++ b/docs/en/api/08-admin.md
@@ -1063,7 +1063,7 @@ Create a new workspace with its first admin user.
**Code Entry Points:**
- `openviking/server/routers/admin.py:create_account` - HTTP route
-- `openviking/server/api_keys/new.py:APIKeyManager.create_account` - Core implementation
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.create_account` - Core implementation
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_create_account` - Python SDK
#### 2. Interface and Parameters
@@ -1252,7 +1252,7 @@ List all workspaces (ROOT only).
**Code Entry Points:**
- `openviking/server/routers/admin.py:list_accounts` - HTTP route
-- `openviking/server/api_keys/new.py:APIKeyManager.get_accounts` - Core implementation
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.get_accounts` - Core implementation
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_list_accounts` - Python SDK
#### 2. Interface and Parameters
@@ -1463,7 +1463,7 @@ Register a new user in a workspace.
**Code Entry Points:**
- `openviking/server/routers/admin.py:register_user` - HTTP route
-- `openviking/server/api_keys/new.py:APIKeyManager.register_user` - Core implementation
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.register_user` - Core implementation
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_register_user` - Python SDK
#### 2. Interface and Parameters
@@ -1597,7 +1597,7 @@ List active users in a workspace. Users with deletion in progress are omitted.
**Code Entry Points:**
- `openviking/server/routers/admin.py:list_users` - HTTP route
-- `openviking/server/api_keys/new.py:APIKeyManager.get_users` - Core implementation
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.get_users` - Core implementation
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_list_users` - Python SDK
#### 2. Interface and Parameters
@@ -1829,7 +1829,7 @@ Change an account user's role between USER and ADMIN, including promotion and de
**Code Entry Points:**
- `openviking/server/routers/admin.py:set_user_role` - HTTP route
-- `openviking/server/api_keys/new.py:APIKeyManager.set_role` - Core implementation
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.set_role` - Core implementation
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_set_role` - Python SDK
#### 2. Interface and Parameters
@@ -1929,7 +1929,7 @@ Generate and store a user API key. With the default random generation, the old k
**Code Entry Points:**
- `openviking/server/routers/admin.py:regenerate_key` - HTTP route
-- `openviking/server/api_keys/new.py:APIKeyManager.regenerate_key` - Core implementation
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.regenerate_key` - Core implementation
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_regenerate_key` - Python SDK
#### 2. Interface and Parameters
diff --git a/docs/zh/api/08-admin.md b/docs/zh/api/08-admin.md
index 20b2dd5ee..9772dc2da 100644
--- a/docs/zh/api/08-admin.md
+++ b/docs/zh/api/08-admin.md
@@ -921,7 +921,7 @@ User override 并重新继承上述默认值,请 PATCH `{"memory_policy": null
**代码入口:**
- `openviking/server/routers/admin.py:create_account` - HTTP 路由
-- `openviking/server/api_keys/new.py:APIKeyManager.create_account` - 核心实现
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.create_account` - 核心实现
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_create_account` - Python SDK
#### 2. 接口和参数说明
@@ -1108,7 +1108,7 @@ ov --sudo admin create-account acme-private --admin alice \
**代码入口:**
- `openviking/server/routers/admin.py:list_accounts` - HTTP 路由
-- `openviking/server/api_keys/new.py:APIKeyManager.get_accounts` - 核心实现
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.get_accounts` - 核心实现
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_list_accounts` - Python SDK
#### 2. 接口和参数说明
@@ -1319,7 +1319,7 @@ ov --sudo task status <task_id>
**代码入口:**
- `openviking/server/routers/admin.py:register_user` - HTTP 路由
-- `openviking/server/api_keys/new.py:APIKeyManager.register_user` - 核心实现
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.register_user` - 核心实现
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_register_user` - Python SDK
#### 2. 接口和参数说明
@@ -1453,7 +1453,7 @@ ov admin register-user acme bob-private --role user \
**代码入口:**
- `openviking/server/routers/admin.py:list_users` - HTTP 路由
-- `openviking/server/api_keys/new.py:APIKeyManager.get_users` - 核心实现
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.get_users` - 核心实现
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_list_users` - Python SDK
#### 2. 接口和参数说明
@@ -1684,7 +1684,7 @@ ov --sudo admin remove-user acme bob
**代码入口:**
- `openviking/server/routers/admin.py:set_user_role` - HTTP 路由
-- `openviking/server/api_keys/new.py:APIKeyManager.set_role` - 核心实现
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.set_role` - 核心实现
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_set_role` - Python SDK
#### 2. 接口和参数说明
@@ -1784,7 +1784,7 @@ ov --sudo admin set-role acme bob user
**代码入口:**
- `openviking/server/routers/admin.py:regenerate_key` - HTTP 路由
-- `openviking/server/api_keys/new.py:APIKeyManager.regenerate_key` - 核心实现
+- `openviking/server/api_keys/key_mgr.py:APIKeyManager.regenerate_key` - 核心实现
- `sdk/python/openviking_sdk/client.py:SyncHTTPClient.admin_regenerate_key` - Python SDK
#### 2. 接口和参数说明
diff --git a/openviking/server/api_keys/__init__.py b/openviking/server/api_keys/__init__.py
index 0d39d1c35..fe6b78eae 100644
--- a/openviking/server/api_keys/__init__.py
+++ b/openviking/server/api_keys/__init__.py
@@ -2,16 +2,16 @@
# SPDX-License-Identifier: AGPL-3.0
"""API key management facade over complete account stores."""
-from openviking.server.api_keys.new import (
+from openviking.server.api_keys.key_mgr import (
APIKeyManager,
generate_api_key,
- is_new_format_key,
+ is_valid_format_key,
parse_api_key,
)
__all__ = [
"APIKeyManager",
- "is_new_format_key",
+ "is_valid_format_key",
"parse_api_key",
"generate_api_key",
]
diff --git a/openviking/server/api_keys/new.py b/openviking/server/api_keys/key_mgr.py
similarity index 78%
rename from openviking/server/api_keys/new.py
rename to openviking/server/api_keys/key_mgr.py
index f1a10c08d..56ac34c8a 100644
--- a/openviking/server/api_keys/new.py
+++ b/openviking/server/api_keys/key_mgr.py
@@ -6,11 +6,12 @@ import base64
import hashlib
import hmac
import secrets
-from typing import Optional, Tuple
+from typing import Optional, Tuple, TypeGuard
from typing_extensions import deprecated
from openviking.server.account_stores.base import AccountStore
+from openviking.server.account_stores.models import DeletionRecord, UserSummary
from openviking.server.identity import ResolvedIdentity, Role
from openviking_cli.exceptions import (
FailedPreconditionError,
@@ -32,13 +33,13 @@ def _decode_segment(encoded: str) -> str:
return base64.urlsafe_b64decode(encoded.encode("utf-8")).decode("utf-8")
-def is_new_format_key(api_key: str) -> bool:
+def is_valid_format_key(api_key: str) -> bool:
return bool(api_key) and len(api_key.split(".")) == 3
def parse_api_key(api_key: str) -> Tuple[str, str, str]:
- if not is_new_format_key(api_key):
- raise ValueError("Not a new format API key")
+ if not is_valid_format_key(api_key):
+ raise ValueError("Invalid API key format")
account_id, user_id, secret = api_key.split(".")
return (
_decode_segment(account_id),
@@ -62,7 +63,7 @@ def generate_api_key(account_id: str, user_id: str, seed: Optional[str] = None)
def mask_api_key(api_key: str) -> str:
"""Mask every secret character except the last four; fully hide malformed keys."""
- if not is_new_format_key(api_key):
+ if not is_valid_format_key(api_key):
return "*" * len(api_key)
account, user, secret = api_key.split(".")
visible_length = 4 if len(secret) > 4 else 0
@@ -94,53 +95,56 @@ class APIKeyManager:
async def close(self) -> None:
await self._store.close()
- async def _require_authenticatable_user(self, account_id: str, user_id: str):
+ async def _get_registered_identity(
+ self, account_id: str, user_id: str
+ ) -> ResolvedIdentity | None:
+ """Read and validate the registered identity, or return None if missing.
+
+ Freshness follows the store contract; deletion state is checked separately.
+ """
user = await self.get_user(account_id, user_id)
if user is None:
- raise UnauthenticatedError("Unknown account or user")
- deletion = await self.get_deletion(account_id, user_id)
- if deletion is not None:
- raise UnauthenticatedError("Invalid API key")
- return user
+ return None
+ try:
+ registered_role = Role.parse(user["role"])
+ if registered_role == Role.ROOT:
+ raise ValueError("ROOT is not an account role")
+ except (KeyError, ValueError):
+ raise UnauthenticatedError("Registered account identity has an invalid role") from None
+ return ResolvedIdentity(role=registered_role, account_id=account_id, user_id=user_id)
- async def _require_manageable_user(self, account_id: str, user_id: str):
- account = await self.get_account(account_id)
- if account is None:
- raise NotFoundError(account_id, "account")
- if account["status"] != "active":
- raise FailedPreconditionError(
- "Account deletion is in progress",
- details={"task_id": account.get("task_id")},
- )
- user = await self.get_user_for_management(account_id, user_id)
- if user is None:
- raise NotFoundError(user_id, "user")
- deletion = await self.get_deletion(account_id, user_id)
- if deletion is not None:
- raise FailedPreconditionError(
- "User deletion is in progress",
- details={"task_id": deletion.get("task_id")},
- )
- return user
+ @staticmethod
+ def _is_authenticatable_identity(
+ identity: ResolvedIdentity | None, deletion: DeletionRecord | None
+ ) -> TypeGuard[ResolvedIdentity]:
+ """Check whether the identity exists and has no account or user deletion record."""
+ return identity is not None and deletion is None
+
+ @staticmethod
+ def _is_manageable_user(user: UserSummary | None, deletion: DeletionRecord | None) -> bool:
+ """Check whether the user exists and has no deletion record.
+
+ The caller must first confirm that the account exists and is active.
+ """
+ return user is not None and deletion is None
async def resolve_identity(self, api_key: str) -> ResolvedIdentity:
if self._root_api_key and hmac.compare_digest(api_key, self._root_api_key):
return ResolvedIdentity(role=Role.ROOT)
account_id, user_id = await self._verify_key(api_key)
- user = await self._require_authenticatable_user(account_id, user_id)
- return ResolvedIdentity(
- role=Role(user["role"]),
- account_id=account_id,
- user_id=user_id,
- )
+ identity = await self._get_registered_identity(account_id, user_id)
+ deletion = await self.get_deletion(account_id, user_id) if identity is not None else None
+ if not self._is_authenticatable_identity(identity, deletion):
+ raise UnauthenticatedError("Account identity does not exist or is being deleted")
+ return identity
async def _verify_key(self, key: str):
- if not is_new_format_key(key):
- raise UnauthenticatedError("Invalid API key")
+ if not is_valid_format_key(key):
+ raise UnauthenticatedError("Invalid API key format")
try:
account_id, user_id, _ = parse_api_key(key)
except (ValueError, UnicodeError):
- raise UnauthenticatedError("Invalid API key") from None
+ raise UnauthenticatedError("Invalid API key format") from None
binding = await self._store.verify_api_key(
key, account_id_hint=account_id, user_id_hint=user_id
)
@@ -183,7 +187,23 @@ class APIKeyManager:
async def regenerate_key(self, account_id, user_id, seed=None, *, expected_api_key=None):
if not self._issue_user_keys:
raise FailedPreconditionError("Personal API keys are disabled in trusted mode")
- await self._require_manageable_user(account_id, user_id)
+ account = await self.get_account(account_id)
+ if account is None:
+ raise NotFoundError(account_id, "account")
+ if account["status"] != "active":
+ raise FailedPreconditionError(
+ "Account deletion is in progress",
+ details={"task_id": account.get("task_id")},
+ )
+ user = await self.get_user_for_management(account_id, user_id)
+ if user is None:
+ raise NotFoundError(user_id, "user")
+ deletion = await self.get_deletion(account_id, user_id)
+ if not self._is_manageable_user(user, deletion):
+ raise FailedPreconditionError(
+ "User deletion is in progress",
+ details={"task_id": deletion.get("task_id")},
+ )
key = generate_api_key(account_id, user_id, seed)
await self._store.replace_active_user_api_key(
account_id, user_id, key, expected_api_key=expected_api_key
@@ -191,20 +211,31 @@ class APIKeyManager:
return key
async def get_registered_user_role(self, account_id: str, user_id: str) -> Role | None:
- user = await self.get_user(account_id, user_id)
- return Role(user["role"]) if user else None
+ identity = await self._get_registered_identity(account_id, user_id)
+ return identity.role if identity is not None else None
async def resolve_oauth_identity(
self, account_id: str, user_id: str, role: Role
) -> ResolvedIdentity:
- user = await self._require_authenticatable_user(account_id, user_id)
- if role.rank > Role(user["role"]).rank:
+ registered_identity = await self._get_registered_identity(account_id, user_id)
+ deletion = (
+ await self.get_deletion(account_id, user_id)
+ if registered_identity is not None
+ else None
+ )
+ if not self._is_authenticatable_identity(registered_identity, deletion):
+ raise UnauthenticatedError("Account identity does not exist or is being deleted")
+ try:
+ authorized_account_role = Role.parse(role)
+ except ValueError:
+ raise UnauthenticatedError("Invalid OAuth authorization role") from None
+ if not registered_identity.role.allows_token_role(authorized_account_role):
raise UnauthenticatedError(
"OAuth token's embedded role exceeds the user's current role; "
"please re-authorize the client."
)
return ResolvedIdentity(
- role=role,
+ role=authorized_account_role,
account_id=account_id,
user_id=user_id,
from_oauth=True,
@@ -267,9 +298,7 @@ class APIKeyManager:
)
if name in filters
}
- page = await self._store.list_users_page(
- account_id, **store_filters
- )
+ page = await self._store.list_users_page(account_id, **store_filters)
if not expose_key or not self._issue_user_keys:
page["key_count"] = 0
for user in page["users"]:
diff --git a/openviking/server/app.py b/openviking/server/app.py
index 7809a6540..a4458f72b 100644
--- a/openviking/server/app.py
+++ b/openviking/server/app.py
@@ -705,11 +705,11 @@ def create_app(
or "http://127.0.0.1:1933"
)
- async def _current_role(account_id: str, user_id: str) -> Role:
+ async def _registered_account_role(account_id: str, user_id: str) -> Role | None:
manager = getattr(app.state, "api_key_manager", None)
if manager is None:
- return Role.USER
- return await manager.get_registered_user_role(account_id, user_id) or Role.USER
+ return None
+ return await manager.get_registered_user_role(account_id, user_id)
_route_provider = OpenVikingOAuthProvider(
store=_route_store,
@@ -717,7 +717,7 @@ def create_app(
access_token_ttl_seconds=ov_cfg.oauth.access_token_ttl_seconds,
refresh_token_ttl_seconds=ov_cfg.oauth.refresh_token_ttl_seconds,
auth_code_ttl_seconds=ov_cfg.oauth.auth_code_ttl_seconds,
- role_resolver=_current_role,
+ role_resolver=_registered_account_role,
)
# Stash the route-time instances; the lifespan replaces these with
# initialized copies before the first request lands.
diff --git a/openviking/server/auth/__init__.py b/openviking/server/auth/__init__.py
index ace1ff18c..10f27b3e4 100644
--- a/openviking/server/auth/__init__.py
+++ b/openviking/server/auth/__init__.py
@@ -218,22 +218,28 @@ async def _context_from_signed_token(
) -> RequestContext:
"""Rebuild the request context bound to a consumed upload/download token.
- In API-key mode the issuing role is retained only while the account user exists and has
- not been downgraded. Other auth modes retain their USER token context.
+ In API-key mode the saved authorization role must remain compatible with the
+ registered account role. Other auth modes retain their USER token context.
"""
if _auth_mode(request) == AuthMode.API_KEY:
manager = get_api_key_manager_or_raise(request)
- current_role = await manager.get_registered_user_role(consumed.account_id, consumed.user_id)
- if current_role is None:
+ registered_account_role = await manager.get_registered_user_role(
+ consumed.account_id, consumed.user_id
+ )
+ if registered_account_role is None:
raise UnauthenticatedError("Signed token's user no longer exists")
- if Role(consumed.role).rank > current_role.rank:
+ try:
+ authorized_account_role = Role.parse(consumed.role)
+ except ValueError:
+ raise UnauthenticatedError("Invalid signed-token authorization role") from None
+ if not registered_account_role.allows_token_role(authorized_account_role):
raise UnauthenticatedError(
"Signed token's role exceeds the user's current role; request a new token"
)
return await _build_request_context(
request,
ResolvedIdentity(
- role=consumed.role,
+ role=authorized_account_role,
account_id=consumed.account_id,
user_id=consumed.user_id,
from_oauth=consumed.from_oauth,
diff --git a/openviking/server/identity.py b/openviking/server/identity.py
index 25a79c9e3..857f39fb2 100644
--- a/openviking/server/identity.py
+++ b/openviking/server/identity.py
@@ -17,9 +17,12 @@ from openviking_cli.session.user_id import UserIdentifier
class Role(str):
"""Role type — supports built-in roles and custom plugin-defined roles.
- Built-in roles (root/admin/user) are available as class attributes.
+ Built-in roles (root/admin/user/global) are available as class attributes.
Custom roles can be registered via ``Role.register(name, rank)``.
+ GLOBAL is reserved for account-scoped identities. Its capabilities are
+ orthogonal to ADMIN and must not be inferred from rank.
+
Role comparison is string-based, so ``Role.ROOT == "root"`` and
``Role("custom") == "custom"`` both work.
"""
@@ -27,9 +30,9 @@ class Role(str):
ROOT = "root"
ADMIN = "admin"
USER = "user"
+ GLOBAL = "global"
- # Privilege ranking for role-downgrade detection.
- # Higher rank => more privilege.
+ # Legacy ranking for token role-downgrade checks, not request authorization.
_BUILTIN_RANK: dict[str, int] = {
USER: 0,
ADMIN: 1,
@@ -45,12 +48,44 @@ class Role(str):
name: Role identifier string.
rank: Privilege rank — higher = more privilege.
"""
+ if not isinstance(name, str) or not name:
+ raise ValueError("Custom role name must be a non-empty string")
+ if name in (cls.ROOT, cls.ADMIN, cls.USER, cls.GLOBAL):
+ raise ValueError("Built-in roles cannot be registered as custom roles")
+ if not isinstance(rank, int) or isinstance(rank, bool):
+ raise ValueError("Custom role rank must be an integer")
cls._CUSTOM_RANK[name] = rank
+ @classmethod
+ def parse(cls, value: object) -> Role:
+ """Validate a role before it enters an identity or request context.
+
+ Construction remains string-compatible. Only enabled built-in roles
+ and explicitly registered custom roles may become internal identities.
+ GLOBAL remains reserved until its authorization rules are implemented.
+ """
+ if not isinstance(value, str) or (
+ value not in (cls.ROOT, cls.ADMIN, cls.USER) and value not in cls._CUSTOM_RANK
+ ):
+ raise ValueError("Unknown or inactive identity role")
+ return cls(value)
+
@property
def rank(self) -> int:
- """Return the privilege rank for this role."""
- return self._BUILTIN_RANK.get(self, self._CUSTOM_RANK.get(self, 0))
+ """Return the legacy token rank; unknown roles have no implicit rank."""
+ if self in self._BUILTIN_RANK:
+ return self._BUILTIN_RANK[self]
+ if self in self._CUSTOM_RANK:
+ return self._CUSTOM_RANK[self]
+ raise ValueError("Role has no legacy token rank")
+
+ def allows_token_role(self, authorized_role: str) -> bool:
+ """Check a saved authorization role against this registered role.
+
+ This preserves legacy token compatibility, not operation permissions.
+ Neither role is allowed to acquire an implicit rank.
+ """
+ return self.parse(authorized_role).rank <= self.rank
def __eq__(self, other: object) -> bool:
if isinstance(other, Role):
@@ -90,6 +125,9 @@ class ResolvedIdentity:
# account/user.
from_oauth: bool = False
+ def __post_init__(self) -> None:
+ self.role = Role.parse(self.role)
+
@dataclass
class RequestContext:
@@ -115,6 +153,9 @@ class RequestContext:
# the triggering user's resource ACL. Tenant and namespace checks still apply.
bypass_acl: bool = False
+ def __post_init__(self) -> None:
+ self.role = Role.parse(self.role)
+
@property
def account_id(self) -> str:
return self.user.account_id
diff --git a/openviking/server/oauth/provider.py b/openviking/server/oauth/provider.py
index 5e6edd82e..180c0571b 100644
--- a/openviking/server/oauth/provider.py
+++ b/openviking/server/oauth/provider.py
@@ -98,7 +98,7 @@ class OpenVikingOAuthProvider(
refresh_token_ttl_seconds: int = 30 * 24 * 3600,
auth_code_ttl_seconds: int = 300,
authorize_page_path: str = DEFAULT_AUTHORIZE_PAGE,
- role_resolver: Optional[Callable[[str, str], Role | Awaitable[Role]]] = None,
+ role_resolver: Optional[Callable[[str, str], Role | None | Awaitable[Role | None]]] = None,
) -> None:
self._store = store
self._issuer = issuer.rstrip("/")
@@ -106,11 +106,8 @@ class OpenVikingOAuthProvider(
self._refresh_ttl = refresh_token_ttl_seconds
self._code_ttl = auth_code_ttl_seconds
self._authorize_page = authorize_page_path
- # Optional callback to look up a user's current role at refresh time.
- # When supplied, exchange_refresh_token will reject if the embedded
- # role outranks the current role — mirrors the bearer-auth check so
- # that `set_role` demotion can't be laundered through token rotation.
- # Wired in app.py from the APIKeyManager.
+ # Optional account-registry lookup used to validate the saved
+ # authorization role at refresh time, matching bearer authentication.
self._role_resolver = role_resolver
# ---- Clients (DCR) ----
@@ -287,22 +284,21 @@ class OpenVikingOAuthProvider(
refresh_token: OVRefreshToken,
scopes: list[str],
) -> OAuthToken:
- # Role downgrade gate: if the embedded role outranks the user's
- # current role (post-`set_role` demotion), refuse to rotate. Same
- # invariant the bearer-auth path enforces; checked here so a
- # demoted user can't keep minting fresh access tokens at the old
- # privilege level just because they hold a long-lived refresh.
+ # Validate the saved authorization role without replacing it with
+ # the account-registry role. Registry reads may be cached.
if self._role_resolver is not None:
try:
- token_role = Role(refresh_token.role)
+ authorized_account_role = Role.parse(refresh_token.role)
resolved = self._role_resolver(refresh_token.account_id, refresh_token.user_id)
- current_role = Role(await resolved if inspect.isawaitable(resolved) else resolved)
+ registered_account_role = Role.parse(
+ await resolved if inspect.isawaitable(resolved) else resolved
+ )
except Exception as exc:
raise TokenError(
error="invalid_grant",
error_description="Unable to validate current identity; re-authorize the client",
) from exc
- if token_role.rank > current_role.rank:
+ if not registered_account_role.allows_token_role(authorized_account_role):
raise TokenError(
error="invalid_grant",
error_description=(
diff --git a/openviking/server/store_assembly.py b/openviking/server/store_assembly.py
index 9b462f6c5..6ab118482 100644
--- a/openviking/server/store_assembly.py
+++ b/openviking/server/store_assembly.py
@@ -12,7 +12,7 @@ from openviking.storage.viking_fs import VikingFS
from openviking_cli.exceptions import InvalidArgumentError
if TYPE_CHECKING:
- from openviking.server.api_keys.new import APIKeyManager
+ from openviking.server.api_keys.key_mgr import APIKeyManager
def build_api_key_manager(
@@ -29,7 +29,7 @@ def build_api_key_manager(
account_store: AccountStore | None = None,
) -> APIKeyManager:
"""Assemble the API key facade over one complete account store."""
- from openviking.server.api_keys.new import APIKeyManager
+ from openviking.server.api_keys.key_mgr import APIKeyManager
provider = account_store_provider.strip().lower()
store = build_account_store(
diff --git a/tests/integration/test_encryption_integration.py b/tests/integration/test_encryption_integration.py
index 1091a7eee..9450aa00c 100644
--- a/tests/integration/test_encryption_integration.py
+++ b/tests/integration/test_encryption_integration.py
@@ -17,7 +17,7 @@ import pytest_asyncio
from openviking.crypto.config import bootstrap_encryption
from openviking.crypto.encryptor import FileEncryptor
from openviking.crypto.providers import LocalFileProvider
-from openviking.server.api_keys import is_new_format_key
+from openviking.server.api_keys import is_valid_format_key
from openviking.server.store_assembly import build_api_key_manager
from openviking.service.core import OpenVikingService
from openviking_cli.session.user_id import UserIdentifier
@@ -302,7 +302,7 @@ class TestVikingFSEncryptionWithAccounts:
# Verify account created successfully
assert user_key is not None
- assert is_new_format_key(user_key)
+ assert is_valid_format_key(user_key)
# RAGFS /local/... paths map to test_data_dir/viking/viking/...
# because OpenVikingService path is test_data_dir/viking,
@@ -348,7 +348,7 @@ class TestVikingFSEncryptionWithAccounts:
# Verify user registered successfully
assert new_user_key is not None
- assert is_new_format_key(new_user_key)
+ assert is_valid_format_key(new_user_key)
# AGFS /local/... paths map to test_data_dir/viking/viking/...
agfs_data_root = test_data_dir / "viking" / "viking"
@@ -548,7 +548,7 @@ This is a test skill for verifying encryption functionality.
admin_user_key = await api_key_manager.create_account(test_account_id, test_admin_user_id)
assert admin_user_key is not None
- assert is_new_format_key(admin_user_key)
+ assert is_valid_format_key(admin_user_key)
# 2. Verify list-accounts operation
print("[2] Verify list-accounts operation")
@@ -565,7 +565,7 @@ This is a test skill for verifying encryption functionality.
print(f"[3] Register test user: {test_user_id}")
test_user_key = await api_key_manager.register_user(test_account_id, test_user_id, "user")
assert test_user_key is not None
- assert is_new_format_key(test_user_key)
+ assert is_valid_format_key(test_user_key)
# 4. Verify list-users operation
print("[4] Verify list-users operation")
@@ -1175,12 +1175,12 @@ class TestAddResourceWithSemanticProcessing:
print(f"[1] Create test account: {test_account_id}")
admin_user_key = await api_key_manager.create_account(test_account_id, test_admin_user_id)
assert admin_user_key is not None
- assert is_new_format_key(admin_user_key)
+ assert is_valid_format_key(admin_user_key)
print(f"[2] Register test user: {test_user_id}")
test_user_key = await api_key_manager.register_user(test_account_id, test_user_id, "user")
assert test_user_key is not None
- assert is_new_format_key(test_user_key)
+ assert is_valid_format_key(test_user_key)
from openviking.server.identity import RequestContext, Role
from openviking_cli.session.user_id import UserIdentifier
diff --git a/tests/integration/test_volcengine_kms_encryption_integration.py b/tests/integration/test_volcengine_kms_encryption_integration.py
index 02f471940..0dacf45cc 100644
--- a/tests/integration/test_volcengine_kms_encryption_integration.py
+++ b/tests/integration/test_volcengine_kms_encryption_integration.py
@@ -19,7 +19,7 @@ import pytest_asyncio
from openviking.crypto.encryptor import FileEncryptor
from openviking.crypto.providers import VolcengineKMSProvider
-from openviking.server.api_keys import is_new_format_key
+from openviking.server.api_keys import is_valid_format_key
from openviking.server.store_assembly import build_api_key_manager
from openviking.service.core import OpenVikingService
from openviking_cli.session.user_id import UserIdentifier
@@ -359,7 +359,7 @@ class TestVikingFSEncryptionWithVolcengineKMS:
user_key = await api_key_manager.create_account(account_id, admin_user_id)
assert user_key is not None
- assert is_new_format_key(user_key)
+ assert is_valid_format_key(user_key)
agfs_data_root = test_data_dir / "viking" / "viking"
diff --git a/tests/server/test_admin_api.py b/tests/server/test_admin_api.py
index 9e53e33d9..e6ce3e9c9 100644
--- a/tests/server/test_admin_api.py
+++ b/tests/server/test_admin_api.py
@@ -3087,7 +3087,7 @@ async def test_user_key_mask_handles_malformed_and_short_keys(key, expected):
async def test_user_key_mask_reveals_only_the_viewers_own_key():
from openviking.server.api_keys import APIKeyManager
- from openviking.server.api_keys.new import generate_api_key, mask_api_key
+ from openviking.server.api_keys.key_mgr import generate_api_key, mask_api_key
alice_key = generate_api_key("acme", "alice")
bob_key = generate_api_key("acme", "bob")
diff --git a/tests/server/test_api_key_manager.py b/tests/server/test_api_key_manager.py
index b7c5b1e4d..a4d036162 100644
--- a/tests/server/test_api_key_manager.py
+++ b/tests/server/test_api_key_manager.py
@@ -69,10 +69,10 @@ async def test_resolve_root_key(manager: APIKeyManager):
assert identity.user_id is None
[email protected]("key", ["wrong-key", ""])
[email protected]("key", ["wrong-key", "", "YWNtZQ.dXNlcg.A"])
async def test_resolve_invalid_key_raises(manager: APIKeyManager, key):
- """Invalid key should raise UnauthenticatedError."""
- with pytest.raises(UnauthenticatedError):
+ """Malformed keys should fail authentication with a format error."""
+ with pytest.raises(UnauthenticatedError, match="^Invalid API key format$"):
await manager.resolve_identity(key)
@@ -767,10 +767,10 @@ async def test_user_and_group_persistence_across_reload(manager_service):
assert await mgr3.get_group_members(acct, group_id) == []
-# ---- New format API Key tests ----
+# ---- API Key format tests ----
-async def test_seeded_new_format_keys_are_predictable(manager: APIKeyManager):
+async def test_seeded_api_keys_are_predictable(manager: APIKeyManager):
from openviking.server.api_keys import parse_api_key
seed = "client-known-seed"
@@ -815,29 +815,78 @@ async def test_seed_must_not_be_empty(manager: APIKeyManager):
await manager.create_account(acct, "alice", seed="")
-async def test_is_new_format_key_validation():
- """Test is_new_format_key correctly identifies key format."""
- from openviking.server.api_keys import generate_api_key, is_new_format_key
+async def test_is_valid_format_key_validation():
+ """Test is_valid_format_key correctly identifies key format."""
+ from openviking.server.api_keys import generate_api_key, is_valid_format_key, parse_api_key
- # Valid new format
+ # Valid API key format
valid_key = generate_api_key("account", "user")
- assert is_new_format_key(valid_key)
+ assert is_valid_format_key(valid_key)
# Bare single-segment keys are not accepted
- assert not is_new_format_key("a" * 64)
+ assert not is_valid_format_key("a" * 64)
# Empty string
- assert not is_new_format_key("")
+ assert not is_valid_format_key("")
# Wrong number of segments
- assert not is_new_format_key("onepart")
- assert not is_new_format_key("two.parts")
- assert not is_new_format_key("too.many.parts.here")
+ assert not is_valid_format_key("onepart")
+ assert not is_valid_format_key("two.parts")
+ assert not is_valid_format_key("too.many.parts.here")
+ with pytest.raises(ValueError, match="^Invalid API key format$"):
+ parse_api_key("two.parts")
# ---- Registered user role ----
[email protected]("delete_account", [False, True])
+async def test_registered_identity_remains_readable_but_unusable_during_deletion(
+ manager: APIKeyManager, delete_account: bool
+):
+ acct = _uid()
+ await manager.create_account(acct, "alice")
+ key = await manager.register_user(acct, "bob", Role.USER)
+ assert (await manager.resolve_oauth_identity(acct, "bob", Role.USER)).role == Role.USER
+
+ await manager.begin_deletion(
+ acct,
+ None if delete_account else "bob",
+ task_id="delete-identity",
+ owner_account_id=acct,
+ owner_user_id="alice",
+ )
+
+ assert await manager.get_registered_user_role(acct, "bob") == Role.USER
+ with pytest.raises(
+ UnauthenticatedError, match="Account identity does not exist or is being deleted"
+ ):
+ await manager.resolve_oauth_identity(acct, "bob", Role.USER)
+ with pytest.raises(UnauthenticatedError, match="Invalid API key"):
+ await manager.resolve_identity(key)
+ target = "Account" if delete_account else "User"
+ with pytest.raises(FailedPreconditionError, match=f"{target} deletion is in progress") as exc:
+ await manager.regenerate_key(acct, "bob")
+ assert exc.value.details == {"task_id": "delete-identity"}
+
+
[email protected]("missing_account", [False, True])
+async def test_missing_identity_fails_authentication_and_management_separately(
+ manager: APIKeyManager, missing_account: bool
+):
+ acct = _uid()
+ if not missing_account:
+ await manager.create_account(acct, "alice")
+
+ assert await manager.get_registered_user_role(acct, "nobody") is None
+ with pytest.raises(
+ UnauthenticatedError, match="Account identity does not exist or is being deleted"
+ ):
+ await manager.resolve_oauth_identity(acct, "nobody", Role.USER)
+ with pytest.raises(NotFoundError):
+ await manager.regenerate_key(acct, "nobody")
+
+
async def test_get_registered_user_role_returns_none_when_user_missing(manager: APIKeyManager):
acct = _uid()
await manager.create_account(acct, "admin_user")
diff --git a/tests/server/test_identity_auth.py b/tests/server/test_identity_auth.py
index 1ee876266..99a8bf2f6 100644
--- a/tests/server/test_identity_auth.py
+++ b/tests/server/test_identity_auth.py
@@ -99,7 +99,9 @@ async def test_key_store_error_and_unknown_identity_fail_closed():
manager = APIKeyManager("root", store)
request = await make_request(manager)
key = generate_api_key("acme", "missing")
- with pytest.raises(UnauthenticatedError, match="Unknown"):
+ with pytest.raises(
+ UnauthenticatedError, match="Account identity does not exist or is being deleted"
+ ):
await request.app.state.auth_plugin.resolve_identity(request, api_key=key)
store.get_user.side_effect = OSError("database offline")
with pytest.raises(OSError, match="database offline"):
diff --git a/tests/storage/test_semantic_processor_identity.py b/tests/storage/test_semantic_processor_identity.py
index f68cddc34..5d18bc67f 100644
--- a/tests/storage/test_semantic_processor_identity.py
+++ b/tests/storage/test_semantic_processor_identity.py
@@ -2,11 +2,14 @@
# SPDX-License-Identifier: Apache-2.0
"""Tests for SemanticProcessor internal context reconstruction."""
+from openviking.server.identity import Role
from openviking.storage.queuefs.semantic_msg import SemanticMsg
from openviking.storage.queuefs.semantic_processor import SemanticProcessor
-def test_ctx_from_semantic_msg_preserves_identity_and_enables_acl_bypass():
+def test_ctx_from_semantic_msg_preserves_identity_and_enables_acl_bypass(monkeypatch):
+ monkeypatch.setattr(Role, "_CUSTOM_RANK", Role._CUSTOM_RANK.copy())
+ Role.register("reviewer", 1)
msg = SemanticMsg(
uri="viking://resources/doc",
context_type="resource",