Skip to content

~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.

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.md
new file mode 100644
index 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.py
index 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",
}
@staticmethod
diff --git a/src/local_deep_research/security/log_sanitizer.py b/src/local_deep_research/security/log_sanitizer.py
index 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.py
new file mode 100644
index 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_TEXT
diff --git a/tests/security/test_data_sanitizer.py b/tests/security/test_data_sanitizer.py
index 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.py
index 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 == expected
def test_count(self):
- assert len(DataSanitizer.DEFAULT_SENSITIVE_KEYS) == 10
+ assert len(DataSanitizer.DEFAULT_SENSITIVE_KEYS) == 15
def 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.py
index 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 result
assert "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)