From 8ea7df6794d31a9b5cc863045d937d4f394b648c Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Mon, 6 Jul 2026 01:56:43 +0800 Subject: [PATCH] =?UTF-8?q?S79=20Secret=E8=84=B1=E6=95=8F=E8=AF=BB?= =?UTF-8?q?=E5=8F=96=E7=AD=96=E7=95=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/services/model_provider_service.py | 21 ++++---- core/secret_service.py | 59 +++++++++++++++++++++- tests/test_core_modules.py | 33 +++++++++++- tests/test_model_provider_service.py | 2 + 4 files changed, 104 insertions(+), 11 deletions(-) diff --git a/backend/services/model_provider_service.py b/backend/services/model_provider_service.py index 0e757cb..947e668 100644 --- a/backend/services/model_provider_service.py +++ b/backend/services/model_provider_service.py @@ -5,6 +5,7 @@ from __future__ import annotations import re from typing import Any +from core.secret_service import redact_provider_secret_state from database.repositories.model_provider_repository import ModelProviderRepository @@ -14,14 +15,16 @@ class ModelProviderService: def upsert_provider(self, payload: dict[str, Any]) -> dict[str, Any]: provider_id = _required_text(payload.get("provider_id"), "provider_id") - return self.repository.upsert_provider( - { - **payload, - "provider_id": provider_id, - "display_name": str(payload.get("display_name") or provider_id), - "provider_type": str(payload.get("provider_type") or "openai_compatible"), - "image_endpoint": str(payload.get("image_endpoint") or "/v1/images/generations"), - } + return redact_provider_secret_state( + self.repository.upsert_provider( + { + **payload, + "provider_id": provider_id, + "display_name": str(payload.get("display_name") or provider_id), + "provider_type": str(payload.get("provider_type") or "openai_compatible"), + "image_endpoint": str(payload.get("image_endpoint") or "/v1/images/generations"), + } + ) ) def upsert_route(self, payload: dict[str, Any]) -> dict[str, Any]: @@ -40,7 +43,7 @@ class ModelProviderService: ) def list_providers(self, *, enabled: bool | None = None) -> list[dict[str, Any]]: - return self.repository.list_providers(enabled=enabled) + return [redact_provider_secret_state(provider) for provider in self.repository.list_providers(enabled=enabled)] def list_routes(self, *, enabled: bool | None = None) -> list[dict[str, Any]]: return self.repository.list_routes(enabled=enabled) diff --git a/core/secret_service.py b/core/secret_service.py index 62bf5b2..8107919 100644 --- a/core/secret_service.py +++ b/core/secret_service.py @@ -4,7 +4,7 @@ from __future__ import annotations import os from dataclasses import dataclass -from typing import Any, Mapping +from typing import Any, Mapping, Protocol MASK = "***MASKED***" @@ -20,6 +20,21 @@ class SecretRef: return {"name": self.name, "is_set": self.is_set, "value": MASK if self.is_set else None} +class SecretStore(Protocol): + def get(self, name: str) -> str | None: + ... + + +@dataclass(frozen=True) +class SecretResolution: + source: str + is_set: bool + value: str | None = None + + def to_public_dict(self) -> dict[str, Any]: + return {"source": self.source, "is_set": self.is_set, "value": MASK if self.is_set else None} + + def is_secret_key(path: str) -> bool: lowered = path.lower() if lowered.endswith("_set"): @@ -53,3 +68,45 @@ def resolve_env_value(reference: str) -> str | None: if not normalized: return None return os.environ.get(normalized) + + +def resolve_secret_value( + *, + env_var: str | None = None, + secret_ref: str | None = None, + plaintext: str | None = None, + secret_store: SecretStore | None = None, +) -> SecretResolution: + normalized_env = str(env_var or "").strip() + if normalized_env: + value = resolve_env_value(normalized_env) + return SecretResolution(source=f"env:{normalized_env.removeprefix('env:')}", is_set=bool(value), value=value) + + normalized_ref = str(secret_ref or "").strip() + if normalized_ref: + value = secret_store.get(normalized_ref) if secret_store else None + return SecretResolution(source=f"secret:{normalized_ref}", is_set=bool(value), value=value) + + normalized_plaintext = str(plaintext or "").strip() + if normalized_plaintext: + return SecretResolution(source="plaintext", is_set=True, value=normalized_plaintext) + + return SecretResolution(source="missing", is_set=False, value=None) + + +def redact_provider_secret_state(provider: Mapping[str, Any]) -> dict[str, Any]: + redacted = dict(provider) + resolution = resolve_secret_value( + env_var=_text(provider.get("api_key_env_var")), + secret_ref=_text(provider.get("api_key_secret_ref")), + plaintext=_text(provider.get("api_key_plaintext")), + ) + redacted.pop("api_key_plaintext", None) + redacted["api_key_secret_ref"] = MASK if provider.get("api_key_secret_ref") else None + redacted["api_key_set"] = resolution.is_set + redacted["api_key_source"] = resolution.source if resolution.source != "plaintext" else "plaintext" + return redacted + + +def _text(value: Any) -> str: + return str(value or "").strip() diff --git a/tests/test_core_modules.py b/tests/test_core_modules.py index 4d69e22..3d55f43 100644 --- a/tests/test_core_modules.py +++ b/tests/test_core_modules.py @@ -10,7 +10,14 @@ from core.interop import PRIVATE_COMPANION, daily_outfit_request, is_allowed_plu from core.model_router import ModelRoute, route_from_capability_profile, select_model_route from core.prompt_pipeline import PromptPart, compose_prompt, merge_prompt_sections from core.queue_manager import QueueManager -from core.secret_service import MASK, env_ref, redact, resolve_env_value +from core.secret_service import ( + MASK, + env_ref, + redact, + redact_provider_secret_state, + resolve_env_value, + resolve_secret_value, +) from core.webhook import WebhookEvent, sign_event, to_sse, verify_signature @@ -133,6 +140,30 @@ class SecretServiceTests(unittest.TestCase): finally: os.environ.pop("IMAGESTUDIO_TEST_SECRET", None) + def test_secret_resolution_prefers_env_and_redacts_public_state(self): + os.environ["IMAGESTUDIO_PROVIDER_KEY"] = "secret-value" + try: + resolution = resolve_secret_value( + env_var="IMAGESTUDIO_PROVIDER_KEY", + plaintext="fallback-value", + ) + public = redact_provider_secret_state( + { + "provider_id": "site_b", + "api_key_env_var": "IMAGESTUDIO_PROVIDER_KEY", + "api_key_secret_ref": "secret/provider/site_b", + "api_key_plaintext": "secret-value", + } + ) + finally: + os.environ.pop("IMAGESTUDIO_PROVIDER_KEY", None) + + self.assertEqual(resolution.value, "secret-value") + self.assertEqual(resolution.to_public_dict()["value"], MASK) + self.assertTrue(public["api_key_set"]) + self.assertEqual(public["api_key_secret_ref"], MASK) + self.assertNotIn("api_key_plaintext", public) + class InteractionTests(unittest.TestCase): def test_actions_are_normalized_and_filtered_by_permission(self): diff --git a/tests/test_model_provider_service.py b/tests/test_model_provider_service.py index 6d168e5..6c00617 100644 --- a/tests/test_model_provider_service.py +++ b/tests/test_model_provider_service.py @@ -52,6 +52,8 @@ class ModelProviderServiceTests(unittest.TestCase): self.assertEqual(resolved["model_id"], "image2") self.assertEqual(resolved["provider"]["base_url"], "https://botcf.com") self.assertEqual(resolved["provider"]["api_key_env_var"], "IMAGESTUDIO_SITE_B_KEY") + self.assertTrue(provider["api_key_set"] in {True, False}) + self.assertNotIn("api_key_plaintext", provider) def test_route_resolution_prefers_lower_priority_enabled_provider(self): self.service.upsert_provider({"provider_id": "slow", "base_url": "https://slow.example"})