~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
security: recognize client_secret/bearer_token/api_secret/… across settings + error-log redaction (#5038)
LearningCircuitcb70800d705a
diff --git a/changelog.d/5038.security.md b/changelog.d/5038.security.mdnew file mode 100644index 0000000000..51c6402911--- /dev/null+++ b/changelog.d/5038.security.md@@ -0,0 +1 @@+`GET /settings/api/bulk` now redacts password-typed settings whose leaf name is a non-classic secret token (e.g. `client_secret`, `secret_key`, `bearer_token`, `api_secret`, `app_secret`). The bulk endpoint redacts by key name only, so these were previously shipped in the clear while the singular GET masked them.diff --git a/src/local_deep_research/security/data_sanitizer.py b/src/local_deep_research/security/data_sanitizer.pyindex 8bf0c2281c..fd6458fda2 100644--- a/src/local_deep_research/security/data_sanitizer.py+++ b/src/local_deep_research/security/data_sanitizer.py@@ -37,6 +37,16 @@ class DataSanitizer:"auth_token","session_token","csrf_token",+ # Additional unambiguous secret leaf-names. The predicate is+ # exact-match on the last dotted segment, so these matter especially+ # for the bulk settings GET, which can only use the key-name heuristic+ # (it passes no ui_element). All are unambiguously secrets and no+ # current setting key uses them for non-secret data.+ "client_secret",+ "secret_key",+ "bearer_token",+ "api_secret",+ "app_secret",}@staticmethoddiff --git a/src/local_deep_research/security/log_sanitizer.py b/src/local_deep_research/security/log_sanitizer.pyindex a1356e6834..b753c38e18 100644--- a/src/local_deep_research/security/log_sanitizer.py+++ b/src/local_deep_research/security/log_sanitizer.py@@ -202,8 +202,9 @@ _CREDENTIAL_PATTERNS: list[tuple[re.Pattern[str], str]] = [re.compile(r"(?i)([?&])("r"api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|"- r"auth[_-]?token|session[_-]?token|secret[_-]?key|"- r"subscription[_-]?key|client[_-]?secret|private[_-]?key|"+ r"auth[_-]?token|session[_-]?token|secret[_-]?key|bearer[_-]?token|"+ r"subscription[_-]?key|client[_-]?secret|api[_-]?secret|"+ r"app[_-]?secret|private[_-]?key|"r"key|token|secret|password|passwd|pwd"r")=([^&\s#]+)"),diff --git a/tests/security/test_bulk_secret_name_coverage.py b/tests/security/test_bulk_secret_name_coverage.pynew file mode 100644index 0000000000..b296907c3e--- /dev/null+++ b/tests/security/test_bulk_secret_name_coverage.py@@ -0,0 +1,44 @@+"""Regression: the bulk settings GET redacts secrets whose leaf name isn't a+classic secret token (client_secret, bearer_token, …).++``GET /settings/api/bulk`` redacts via ``redact_value(key, None, value)`` — it+passes no ``ui_element``, so a password-typed setting is masked only if its leaf+name is in ``DEFAULT_SENSITIVE_KEYS``. These names were previously missing, so+such settings shipped in the clear. Uses a real in-memory ``SettingsManager`` and+mirrors the endpoint's redaction call; fails if a name is dropped from the set.+"""++import pytest+from sqlalchemy import create_engine+from sqlalchemy.orm import sessionmaker++from local_deep_research.database.models import Base+from local_deep_research.database.models.settings import Setting+from local_deep_research.security.data_sanitizer import DataSanitizer+from local_deep_research.settings.manager import SettingsManager+++ "leaf",+ ["client_secret", "secret_key", "bearer_token", "api_secret", "app_secret"],+)+def test_bulk_get_redacts_named_secret(leaf):+ key = f"integrations.oauth.{leaf}"+ engine = create_engine("sqlite:///:memory:")+ Base.metadata.create_all(engine)+ session = sessionmaker(bind=engine)()+ session.add(+ Setting(+ key=key,+ value="topsecret-value",+ type="app",+ name=key,+ ui_element="password",+ )+ )+ session.commit()+ manager = SettingsManager(db_session=session)++ # mirror GET /settings/api/bulk: get_setting(key) then redact_value(key, None, value)+ shipped = DataSanitizer.redact_value(key, None, manager.get_setting(key))+ assert shipped == DataSanitizer.REDACTION_TEXTdiff --git a/tests/security/test_data_sanitizer.py b/tests/security/test_data_sanitizer.pyindex 9d22d704ae..199327c0a2 100644--- a/tests/security/test_data_sanitizer.py+++ b/tests/security/test_data_sanitizer.py@@ -272,6 +272,52 @@ class TestDefaultSensitiveKeys:assert expected.issubset(DataSanitizer.DEFAULT_SENSITIVE_KEYS)+class TestExpandedSecretLeafNames:+ """Secret leaf-names beyond the classic set must be caught by the+ name-only predicate the bulk settings GET relies on (ui_element=None).+ """++ NEW_NAMES = [+ "client_secret",+ "secret_key",+ "bearer_token",+ "api_secret",+ "app_secret",+ ]++ def test_present_in_default_set(self):+ assert set(self.NEW_NAMES).issubset(+ DataSanitizer.DEFAULT_SENSITIVE_KEYS+ )++ def test_recognized_by_leaf(self):+ for name in self.NEW_NAMES:+ key = f"integrations.oauth.{name}"+ assert DataSanitizer.is_sensitive_setting(key)+ # mirrors the bulk GET call: redact_value(key, None, value)+ assert (+ DataSanitizer.redact_value(key, None, "topsecret-value")+ == DataSanitizer.REDACTION_TEXT+ )++ def test_no_over_redaction_of_similar_names(self):+ # exact-leaf match must NOT redact these legit non-secret keys.+ # The last two leaves CONTAIN a sensitive name as a proper substring+ # ("password" in "passwordless", "secret" in "secretary") — they pin+ # the predicate to exact-match, so a substring-broadening regression+ # (e.g. `any(s in leaf ...)`) would be caught here.+ for key in (+ "llm.max_tokens",+ "cache.key",+ "search.public_key",+ "app.token_count",+ "oauth.client_id",+ "llm.passwordless",+ "integrations.secretary",+ ):+ assert DataSanitizer.redact_value(key, None, "value") == "value"++class TestEdgeCases:"""Edge case tests for DataSanitizer."""diff --git a/tests/security/test_data_sanitizer_coverage.py b/tests/security/test_data_sanitizer_coverage.pyindex acf71162e9..8e6af3b352 100644--- a/tests/security/test_data_sanitizer_coverage.py+++ b/tests/security/test_data_sanitizer_coverage.py@@ -550,11 +550,16 @@ class TestDefaultSensitiveKeysComplete:"auth_token","session_token","csrf_token",+ "client_secret",+ "secret_key",+ "bearer_token",+ "api_secret",+ "app_secret",}assert DataSanitizer.DEFAULT_SENSITIVE_KEYS == expecteddef test_count(self):- assert len(DataSanitizer.DEFAULT_SENSITIVE_KEYS) == 10+ assert len(DataSanitizer.DEFAULT_SENSITIVE_KEYS) == 15def test_all_lowercase(self):"""All default keys are stored in lowercase."""diff --git a/tests/security/test_sanitize_error_message.py b/tests/security/test_sanitize_error_message.pyindex 726c69d145..c3c0a546ee 100644--- a/tests/security/test_sanitize_error_message.py+++ b/tests/security/test_sanitize_error_message.py@@ -44,6 +44,27 @@ class TestSanitizeErrorMessageStandalone:assert "google-pse-secret-key-value" not in resultassert "key=[REDACTED]" in result+ def test_url_query_named_secrets_redacted(self):+ """Secret-named query params beyond the classic tokens must also be+ redacted, matching DataSanitizer.DEFAULT_SENSITIVE_KEYS."""+ for name in (+ "client_secret",+ "secret_key",+ "bearer_token",+ "api_secret",+ "app_secret",+ ):+ value = f"{name}-oauth-value-here-1234"+ result = sanitize_error_message(f"POST /cb?{name}={value}&x=1")+ assert value not in result, name+ assert f"{name}=[REDACTED]" in result, name++ def test_url_query_client_id_not_redacted(self):+ """client_id is a public identifier, not a secret — stays readable."""+ msg = "?client_id=public-app-id-value-12345&scope=read"+ result = sanitize_error_message(msg)+ assert "public-app-id-value-12345" in result+def test_url_query_token_redacted(self):msg = "?token=secret-token-value-1234567890&page=1"result = sanitize_error_message(msg)