S105 集成令牌轮换

这个提交存在于:
YokiiroBW 2026-07-06 03:55:47 +08:00
父节点 c3b4257e08
当前提交 12b2a379ea
共有 7 个文件被更改,包括 399 次插入 和 3 次删除

查看文件

@ -136,6 +136,8 @@ ROUTES: tuple[RouteSpec, ...] = (
),
RouteSpec("POST", "profiles/{profile_id}/wardrobe/match", "backend.routes.wardrobe_routes.match_wardrobe", "read"),
RouteSpec("POST", "integrations/private-companion/daily-outfit", "backend.routes.integration_routes.private_companion_daily_outfit", "read"),
RouteSpec("GET", "integrations/private-companion/token", "backend.routes.integration_routes.get_private_companion_token_status", "config"),
RouteSpec("POST", "integrations/private-companion/token/rotate", "backend.routes.integration_routes.rotate_private_companion_token", "config"),
RouteSpec("GET", "integrations/logs", "backend.routes.integration_routes.list_integration_logs", "read"),
RouteSpec("GET", "logs/generation", "backend.routes.log_routes.get_generation_logs", "read"),
RouteSpec("GET", "logs/workflows", "backend.routes.log_routes.get_workflow_logs", "read"),

查看文件

@ -6,10 +6,12 @@ from typing import Any
from backend.routes.common import handle_request
from backend.services.integration_service import IntegrationService
from backend.services.integration_token_service import IntegrationTokenService
from backend.services.wardrobe_service import WardrobeService
from core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
from core.security import require_authenticated
from core.security import require_authenticated, require_config_manager
from database.db_helper import Database, load_database_settings
from database.repositories.integration_repository import IntegrationRepository
from database.repositories.material_repository import MaterialRepository
@ -49,6 +51,33 @@ def list_integration_logs(
return handle_request(ctx, action)
def get_private_companion_token_status(
ctx: RequestContext,
service: IntegrationTokenService | None = None,
) -> dict:
token_service = service or _create_token_service()
def action() -> dict[str, Any]:
require_config_manager(ctx)
return token_service.status()
return handle_request(ctx, action)
def rotate_private_companion_token(
ctx: RequestContext,
payload: dict[str, Any] | None = None,
service: IntegrationTokenService | None = None,
) -> dict:
token_service = service or _create_token_service()
def action() -> dict[str, Any]:
require_config_manager(ctx)
return token_service.rotate(payload or {}, ctx)
return handle_request(ctx, action)
def _create_integration_service() -> IntegrationService:
database = Database(load_database_settings())
audit_service = AuditService(database)
@ -61,4 +90,10 @@ def _create_integration_service() -> IntegrationService:
return IntegrationService(
wardrobe_service=wardrobe_service,
integration_repository=IntegrationRepository(database),
token_service=IntegrationTokenService(audit_service=audit_service),
)
def _create_token_service() -> IntegrationTokenService:
database = Database(load_database_settings())
return IntegrationTokenService(ConfigService(), audit_service=AuditService(database))

查看文件

@ -6,8 +6,10 @@ from typing import Any
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.services.integration_token_service import IntegrationTokenService
from backend.services.wardrobe_service import WardrobeService
from core.identity import RequestContext
from core.secret_service import redact
from database.repositories.integration_repository import IntegrationRepository
@ -19,9 +21,11 @@ class IntegrationService:
self,
wardrobe_service: WardrobeService,
integration_repository: IntegrationRepository,
token_service: IntegrationTokenService | None = None,
):
self.wardrobe_service = wardrobe_service
self.integration_repository = integration_repository
self.token_service = token_service
def daily_outfit(self, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
source = str(payload.get("request_source") or PRIVATE_COMPANION)
@ -33,6 +37,12 @@ class IntegrationService:
)
self._record_failure(source, payload, error)
raise error
if self.token_service:
try:
self.token_service.verify(source, _request_token(payload))
except ApiError as exc:
self._record_failure(source, payload, exc)
raise
profile_id = str(payload.get("profile_id") or "").strip()
if not profile_id:
error = ApiError(ErrorCode.VALIDATION_FAILED, "profile_id is required", {"field": "profile_id"})
@ -64,7 +74,7 @@ class IntegrationService:
"integration_name": source,
"action": "daily_outfit",
"status": "succeeded",
"request": payload,
"request": _redact_request(payload),
"response": response,
}
)
@ -90,7 +100,7 @@ class IntegrationService:
"integration_name": source,
"action": "daily_outfit",
"status": "failed",
"request": payload,
"request": _redact_request(payload),
"response": {"error_code": _error_code(exc)},
"error_message": str(getattr(exc, "message", None) or exc),
}
@ -118,6 +128,14 @@ def _wardrobe_match_payload(payload: dict[str, Any], categories: list[str]) -> d
return match_payload
def _request_token(payload: dict[str, Any]) -> str | None:
return str(payload.get("integration_token") or payload.get("token") or "").strip() or None
def _redact_request(payload: dict[str, Any]) -> dict[str, Any]:
return redact(payload)
def _fallback_prompt(payload: dict[str, Any]) -> str:
parts = ["daily outfit"]
for key in ("mood", "weather"):

查看文件

@ -0,0 +1,198 @@
"""Integration token rotation and verification."""
from __future__ import annotations
import hashlib
import hmac
import secrets
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.services.settings_service import _dump_yaml
from core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
from core.interop import PRIVATE_COMPANION
from database.db_helper import _load_yaml_subset
DEFAULT_GRACE_SECONDS = 24 * 60 * 60
MAX_GRACE_SECONDS = 7 * 24 * 60 * 60
class IntegrationTokenService:
def __init__(
self,
config_service: ConfigService | None = None,
*,
audit_service: AuditService | None = None,
):
self.config_service = config_service or ConfigService()
self.audit_service = audit_service
def status(self) -> dict[str, Any]:
security = self._security()
return {
"integration_token_set": _current_token_set(security),
"previous_token_set": _previous_token_set(security),
"allowed_integration_plugins": _allowed_plugins(security),
"rotated_at": security.get("integration_token_rotated_at"),
"previous_expires_at": security.get("previous_integration_token_expires_at"),
}
def rotate(self, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
token = _token_or_generate(payload.get("token"))
grace_seconds = _grace_seconds(payload.get("grace_seconds"))
config = self._load_config()
security = dict(config.get("security") or {})
now = _now()
current_hash = str(security.get("integration_token_hash") or "").strip()
current_salt = str(security.get("integration_token_salt") or "").strip()
if current_hash and current_salt:
security["previous_integration_token_hash"] = current_hash
security["previous_integration_token_salt"] = current_salt
security["previous_integration_token_expires_at"] = _format_time(now + timedelta(seconds=grace_seconds))
else:
security.pop("previous_integration_token_hash", None)
security.pop("previous_integration_token_salt", None)
security.pop("previous_integration_token_expires_at", None)
salt = secrets.token_hex(16)
security["integration_token_hash"] = _hash_token(token, salt)
security["integration_token_salt"] = salt
security["integration_token_rotated_at"] = _format_time(now)
security["integration_token_set"] = True
security.pop("integration_token", None)
config["security"] = security
self._write_config(config)
public_status = self.status()
if self.audit_service:
self.audit_service.record(
ctx=ctx,
action="rotate_integration_token",
target_type="integration",
target_id=PRIVATE_COMPANION,
after_snapshot=public_status,
metadata={"grace_seconds": grace_seconds},
)
return {
"token": token,
"token_preview": _token_preview(token),
"status": public_status,
}
def verify(self, source: str, token: Any) -> dict[str, Any]:
security = self._security()
normalized_source = str(source or "").strip()
allowed_plugins = _allowed_plugins(security)
if allowed_plugins and normalized_source not in allowed_plugins:
raise ApiError(
ErrorCode.INTEGRATION_TOKEN_INVALID,
"integration plugin is not allowed",
{"request_source": normalized_source},
)
if not _current_token_set(security):
return {"valid": True, "required": False, "token_slot": "not_configured"}
candidate = str(token or "").strip()
if not candidate:
raise ApiError(ErrorCode.INTEGRATION_TOKEN_INVALID, "integration token is required", {})
if _matches_hash(candidate, security.get("integration_token_salt"), security.get("integration_token_hash")):
return {"valid": True, "required": True, "token_slot": "current"}
if _previous_token_set(security) and _matches_hash(
candidate,
security.get("previous_integration_token_salt"),
security.get("previous_integration_token_hash"),
):
return {"valid": True, "required": True, "token_slot": "previous"}
legacy_token = str(security.get("integration_token") or "").strip()
if legacy_token and hmac.compare_digest(candidate, legacy_token):
return {"valid": True, "required": True, "token_slot": "legacy"}
raise ApiError(ErrorCode.INTEGRATION_TOKEN_INVALID, "integration token is invalid", {})
def _security(self) -> dict[str, Any]:
return dict(self._load_config().get("security") or {})
def _load_config(self) -> dict[str, Any]:
path = self.config_service.config_path
if not path.exists():
return {}
return _load_yaml_subset(path.read_text(encoding="utf-8"))
def _write_config(self, config: dict[str, Any]) -> None:
path: Path = self.config_service.config_path
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(_dump_yaml(config), encoding="utf-8")
def _current_token_set(security: dict[str, Any]) -> bool:
return bool(security.get("integration_token_hash") or security.get("integration_token"))
def _previous_token_set(security: dict[str, Any]) -> bool:
if not (security.get("previous_integration_token_hash") and security.get("previous_integration_token_salt")):
return False
expires_at = _parse_time(security.get("previous_integration_token_expires_at"))
return expires_at is None or expires_at > _now()
def _allowed_plugins(security: dict[str, Any]) -> list[str]:
plugins = security.get("allowed_integration_plugins")
if isinstance(plugins, list):
normalized = [str(plugin).strip() for plugin in plugins if str(plugin).strip()]
return normalized or [PRIVATE_COMPANION]
return [PRIVATE_COMPANION]
def _token_or_generate(value: Any) -> str:
token = str(value or "").strip() or secrets.token_urlsafe(32)
if len(token) < 16:
raise ApiError(ErrorCode.VALIDATION_FAILED, "integration token must be at least 16 characters", {"field": "token"})
return token
def _grace_seconds(value: Any) -> int:
try:
seconds = int(value)
except (TypeError, ValueError):
seconds = DEFAULT_GRACE_SECONDS
return min(max(seconds, 0), MAX_GRACE_SECONDS)
def _hash_token(token: str, salt: str) -> str:
return hmac.new(salt.encode("utf-8"), token.encode("utf-8"), hashlib.sha256).hexdigest()
def _matches_hash(token: str, salt: Any, digest: Any) -> bool:
normalized_salt = str(salt or "").strip()
normalized_digest = str(digest or "").strip()
if not normalized_salt or not normalized_digest:
return False
return hmac.compare_digest(_hash_token(token, normalized_salt), normalized_digest)
def _now() -> datetime:
return datetime.now(timezone.utc)
def _format_time(value: datetime) -> str:
return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
def _parse_time(value: Any) -> datetime | None:
text = str(value or "").strip()
if not text:
return None
if text.endswith("Z"):
text = text[:-1] + "+00:00"
try:
parsed = datetime.fromisoformat(text)
except ValueError:
return None
if parsed.tzinfo is None:
parsed = parsed.replace(tzinfo=timezone.utc)
return parsed.astimezone(timezone.utc)
def _token_preview(token: str) -> str:
return f"{token[:4]}...{token[-4:]}"

查看文件

@ -6,10 +6,12 @@ from pathlib import Path
from backend.routes.integration_routes import list_integration_logs, private_companion_daily_outfit
from backend.services.integration_service import IntegrationService
from backend.services.integration_token_service import IntegrationTokenService
from backend.services.material_service import MaterialService
from backend.services.profile_service import ProfileService
from backend.services.wardrobe_service import WardrobeService
from core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.integration_repository import IntegrationRepository
@ -119,6 +121,47 @@ class IntegrationServiceTests(unittest.TestCase):
self.assertIn("white blouse", response["final_prompt"])
self.assertIn("matching shoes", response["final_prompt"])
def test_daily_outfit_requires_configured_token_and_redacts_logs(self):
token_config = self.tmp.name and Path(self.tmp.name) / "token_config.yaml"
token_config.write_text(
"""
security:
allowed_integration_plugins:
- astrbot_plugin_private_companion
""",
encoding="utf-8",
)
token_service = IntegrationTokenService(ConfigService(token_config))
token_service.rotate({"token": "daily-token-value"}, self.ctx)
service = IntegrationService(self.wardrobe_service, self.integration_repository, token_service)
with self.assertRaises(Exception):
service.daily_outfit(
{
"profile_id": self.profile.profile_id,
"categories": ["top"],
"integration_token": "wrong-token-value",
},
self.ctx,
)
failed_logs = service.list_integration_logs(status="failed")
self.assertEqual(failed_logs[0]["response"]["error_code"], "INTEGRATION_TOKEN_INVALID")
self.assertEqual(failed_logs[0]["request"]["integration_token"], "***MASKED***")
response = service.daily_outfit(
{
"profile_id": self.profile.profile_id,
"categories": ["top"],
"integration_token": "daily-token-value",
},
self.ctx,
)
self.assertTrue(response["matched"])
succeeded_logs = service.list_integration_logs(status="succeeded")
self.assertEqual(succeeded_logs[0]["request"]["integration_token"], "***MASKED***")
def test_integration_routes_wrap_responses(self):
response = private_companion_daily_outfit(
self.ctx,

查看文件

@ -0,0 +1,98 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.dto.common import ApiError, ErrorCode
from backend.routes.integration_routes import get_private_companion_token_status, rotate_private_companion_token
from backend.services.integration_token_service import IntegrationTokenService
from core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
class IntegrationTokenServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
self.config_path.write_text(
"""
security:
allowed_integration_plugins:
- astrbot_plugin_private_companion
""",
encoding="utf-8",
)
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db")))
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.service = IntegrationTokenService(ConfigService(self.config_path), audit_service=self.audit_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_manage_config"},
)
def tearDown(self):
self.tmp.cleanup()
def test_rotate_hashes_token_and_accepts_previous_during_grace(self):
first = self.service.rotate({"token": "first-token-value", "grace_seconds": 3600}, self.ctx)
second = self.service.rotate({"token": "second-token-value", "grace_seconds": 3600}, self.ctx)
self.assertEqual(first["token"], "first-token-value")
self.assertEqual(second["token_preview"], "seco...alue")
self.assertTrue(self.service.status()["integration_token_set"])
self.assertTrue(self.service.status()["previous_token_set"])
self.assertEqual(
self.service.verify("astrbot_plugin_private_companion", "second-token-value")["token_slot"],
"current",
)
self.assertEqual(
self.service.verify("astrbot_plugin_private_companion", "first-token-value")["token_slot"],
"previous",
)
config_text = self.config_path.read_text(encoding="utf-8")
self.assertNotIn("first-token-value", config_text)
self.assertNotIn("second-token-value", config_text)
def test_verify_rejects_missing_or_bad_token_when_configured(self):
self.service.rotate({"token": "first-token-value"}, self.ctx)
for token in (None, "bad-token-value"):
with self.assertRaises(ApiError) as raised:
self.service.verify("astrbot_plugin_private_companion", token)
self.assertEqual(raised.exception.error_code, ErrorCode.INTEGRATION_TOKEN_INVALID)
def test_verify_is_optional_until_token_is_configured(self):
self.assertFalse(self.service.status()["integration_token_set"])
result = self.service.verify("astrbot_plugin_private_companion", None)
self.assertFalse(result["required"])
def test_token_routes_require_config_permission_and_return_token_once(self):
rotated = rotate_private_companion_token(
self.ctx,
{"token": "route-token-value"},
self.service,
)
self.assertTrue(rotated["ok"])
self.assertEqual(rotated["data"]["token"], "route-token-value")
self.assertTrue(rotated["data"]["status"]["integration_token_set"])
status = get_private_companion_token_status(self.ctx, self.service)
self.assertTrue(status["ok"])
self.assertNotIn("route-token-value", str(status["data"]))
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = rotate_private_companion_token(read_only, {"token": "another-token-value"}, self.service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
if __name__ == "__main__":
unittest.main()

查看文件

@ -33,6 +33,8 @@ class RouteRegistryTests(unittest.TestCase):
self.assertIn(("GET", "materials/{material_id}"), keys)
self.assertIn(("DELETE", "profiles/{profile_id}/wardrobe/{wardrobe_item_id}"), keys)
self.assertIn(("DELETE", "profiles/{profile_id}/wardrobe/items/{wardrobe_item_id}"), keys)
self.assertIn(("GET", "integrations/private-companion/token"), keys)
self.assertIn(("POST", "integrations/private-companion/token/rotate"), keys)
self.assertIn(("GET", "integrations/logs"), keys)
self.assertIn(("POST", "workflows/{workflow_id}/start"), keys)
self.assertIn(("POST", "workflows/{workflow_id}/cancel"), keys)