~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: stop /settings/api/bulk leaking nested plaintext secrets (#5028)
LearningCircuit8af91a4ea9e3
diff --git a/changelog.d/5028.security.md b/changelog.d/5028.security.mdnew file mode 100644index 0000000000..3cea338e05--- /dev/null+++ b/changelog.d/5028.security.md@@ -0,0 +1 @@+Fixed a plaintext-secret disclosure in `GET /settings/api/bulk`: a namespace request (e.g. `keys[]=llm`) returned nested `*.api_key` values unredacted because the redaction check looked only at the outer requested key, and `keys[]=%` could dump the whole settings table via an unescaped `LIKE`. Redaction now recurses into setting subtrees and the key lookup escapes LIKE wildcards.diff --git a/src/local_deep_research/security/data_sanitizer.py b/src/local_deep_research/security/data_sanitizer.pyindex 8abfa13871..8bf0c2281c 100644--- a/src/local_deep_research/security/data_sanitizer.py+++ b/src/local_deep_research/security/data_sanitizer.py@@ -83,11 +83,38 @@ class DataSanitizer:Empty values (``None``, ``""``, ``[]``, ``{}``) are left readable sothe UI can tell "configured" from "not configured" without leakingthat a secret is set.++ Nested containers are redacted recursively: a subtree request such as+ ``get_setting("llm")`` returns ``{"openai.api_key": "sk-…", …}`` where+ the outer key (``llm``) is not sensitive but inner keys are, and a JSON+ setting value may be a list of dicts (e.g. ``[{"api_key": "sk-…"}]``).+ Without the recursion, ``GET /settings/api/bulk?keys[]=llm`` would ship+ those nested secrets in the clear. A sensitive OUTER key still masks its+ whole value wholesale (the check below runs first), so plain lists under+ a non-sensitive key pass through untouched."""if DataSanitizer.is_sensitive_setting(key, ui_element, sensitive_keys) and value not in (None, "", [], {}):return redaction_text+ if isinstance(value, dict):+ redacted: dict = {}+ for sub_key, sub_val in value.items():+ nested_key = f"{key}.{sub_key}" if key else sub_key+ redacted[sub_key] = DataSanitizer.redact_value(+ nested_key, None, sub_val, sensitive_keys, redaction_text+ )+ return redacted+ if isinstance(value, list):+ # List items reuse the parent key; a dict item is caught by the+ # branch above (its own sensitive leaves get masked), a plain+ # scalar item passes through.+ return [+ DataSanitizer.redact_value(+ key, None, item, sensitive_keys, redaction_text+ )+ for item in value+ ]return value@staticmethoddiff --git a/src/local_deep_research/settings/manager.py b/src/local_deep_research/settings/manager.pyindex 1a4dc6ec30..0992e7e151 100644--- a/src/local_deep_research/settings/manager.py+++ b/src/local_deep_research/settings/manager.py@@ -14,6 +14,7 @@ from sqlalchemy.orm import Sessionfrom .. import defaultsfrom ..__version__ import __version__ as package_versionfrom ..database.models import Setting, SettingType+from ..utilities.sql_utils import escape_likefrom ..utilities.type_utils import to_boolfrom ..web.models.settings import (AppSetting,@@ -580,11 +581,18 @@ class SettingsManager(ISettingsManager):# subkey of ``foo`` and cause ``get_setting`` to return# a 2-key dict (``{"": value, "foo": value}``) instead# of the primitive. See embedding-settings page bug.+ # escape_like: the requested key is user-supplied (e.g. via+ # /settings/api/bulk?keys[]=...), so escape its LIKE wildcards+ # or ``keys[]=%`` would match every dotted key and dump the+ # whole table. The ``!= f"{key}."`` guard compares against the+ # raw stored key, so it stays unescaped.query = query.filter(or_(Setting.key == key,and_(- Setting.key.like(f"{key}.%"),+ Setting.key.like(+ f"{escape_like(key)}.%", escape="\\"+ ),Setting.key != f"{key}.",),)diff --git a/tests/security/test_data_sanitizer.py b/tests/security/test_data_sanitizer.pyindex 9da5bd1805..9d22d704ae 100644--- a/tests/security/test_data_sanitizer.py+++ b/tests/security/test_data_sanitizer.py@@ -401,3 +401,56 @@ class TestStripSettingsSnapshot:_ = strip_settings_snapshot(original)assert "settings_snapshot" in originalassert original["settings_snapshot"]["api_key"] == "sk-secret"+++class TestRedactValueNestedDict:+ """redact_value must recurse into subtree dicts.++ A namespace request (e.g. get_setting("llm")) returns a nested dict whose+ outer key is not sensitive but whose inner keys are — without recursion+ those nested secrets would ship in the clear via GET /settings/api/bulk.+ """++ def test_nested_sensitive_leaf_redacted(self):+ value = {"provider": "openai", "openai.api_key": "sk-secret"}+ out = DataSanitizer.redact_value("llm", None, value)+ assert out["openai.api_key"] == DataSanitizer.REDACTION_TEXT+ assert out["provider"] == "openai"++ def test_deeply_nested_secret_redacted(self):+ value = {"openai": {"api_key": "sk-secret"}}+ out = DataSanitizer.redact_value("llm", None, value)+ assert out["openai"]["api_key"] == DataSanitizer.REDACTION_TEXT++ def test_sensitive_outer_key_with_dict_redacted_wholesale(self):+ # A sensitive-named key holding a dict is masked entirely (not recursed)+ out = DataSanitizer.redact_value("x.api_key", None, {"nested": "v"})+ assert out == DataSanitizer.REDACTION_TEXT++ def test_primitive_value_unchanged(self):+ assert (+ DataSanitizer.redact_value("llm.provider", None, "openai")+ == "openai"+ )++ def test_empty_dict_unchanged(self):+ assert DataSanitizer.redact_value("llm", None, {}) == {}++ def test_list_of_dicts_secret_redacted(self):+ # a JSON list-of-dicts leaf (e.g. mcp.servers) must not ship secrets+ value = [{"name": "prod", "api_key": "sk-secret"}]+ out = DataSanitizer.redact_value("mcp.servers", None, value)+ assert out[0]["api_key"] == DataSanitizer.REDACTION_TEXT+ assert out[0]["name"] == "prod"++ def test_plain_list_unchanged(self):+ # a list of scalars under a non-sensitive key is not mangled+ value = ["host1", "host2"]+ assert DataSanitizer.redact_value("search.hosts", None, value) == [+ "host1",+ "host2",+ ]++ def test_sensitive_key_with_list_redacted_wholesale(self):+ out = DataSanitizer.redact_value("x.secret", None, ["a", "b"])+ assert out == DataSanitizer.REDACTION_TEXTdiff --git a/tests/security/test_settings_bulk_secret_leak.py b/tests/security/test_settings_bulk_secret_leak.pynew file mode 100644index 0000000000..edb3a03760--- /dev/null+++ b/tests/security/test_settings_bulk_secret_leak.py@@ -0,0 +1,121 @@+"""Regression: GET /settings/api/bulk must not leak nested plaintext secrets.++Two intertwined defects, fixed together:++- ``DataSanitizer.redact_value`` did not recurse into subtree dicts, so a+ namespace request (``keys[]=llm`` -> ``get_setting("llm")`` returns+ ``{"openai.api_key": "sk-...", ...}``) shipped nested secrets in the clear,+ because the outer key ``llm`` is not itself sensitive.+- ``SettingsManager.__query_settings`` interpolated the caller-supplied key+ into a ``LIKE`` pattern unescaped, so ``keys[]=%`` matched every dotted key+ and dumped the whole settings table.++These use a real in-memory ``SettingsManager`` so the actual LIKE query and+subtree assembly run; each fails if its fix is reverted.+"""++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++_SECRET = "sk-REALSECRET12345"+++def _manager(rows):+ engine = create_engine("sqlite:///:memory:")+ Base.metadata.create_all(engine)+ session = sessionmaker(bind=engine)()+ for key, value in rows:+ session.add(Setting(key=key, value=value, type="app", name=key))+ session.commit()+ return SettingsManager(db_session=session)+++def _bulk_value(manager, key):+ """Mirror what GET /settings/api/bulk ships for one requested key."""+ return DataSanitizer.redact_value(key, None, manager.get_setting(key))+++def test_namespace_request_does_not_leak_nested_secret():+ """keys[]=llm must redact nested *.api_key, not ship them plaintext."""+ manager = _manager(+ [+ ("llm.provider", "openai"),+ ("llm.openai.api_key", _SECRET),+ ]+ )+ shipped = _bulk_value(manager, "llm")++ assert _SECRET not in str(shipped)+ assert shipped["openai.api_key"] == DataSanitizer.REDACTION_TEXT+ # non-secret siblings stay readable+ assert shipped["provider"] == "openai"+++def test_wildcard_key_does_not_dump_settings_table():+ """keys[]=% must not wildcard-match every dotted setting."""+ manager = _manager(+ [+ ("llm.provider", "openai"),+ ("llm.openai.api_key", _SECRET),+ ("search.max_results", "10"),+ ]+ )+ # With the bug, get_setting("%") returns a populated dump of the table.+ assert not manager.get_setting("%")+++def test_underscore_in_key_matched_literally():+ """A requested key with '_' must not act as a single-char wildcard."""+ manager = _manager(+ [+ ("a_b.foo", "t1"),+ ("a_b.baz", "t2"),+ ("axb.bar", "decoy"),+ ]+ )+ # subtree request 'a_b' must not also pull 'axb.*' via the '_' wildcard+ result = manager.get_setting("a_b")+ assert result == {"foo": "t1", "baz": "t2"}+ assert "bar" not in result+++def test_exact_secret_request_still_redacted():+ """Regression: an exact keys[]=llm.openai.api_key stays redacted."""+ manager = _manager([("llm.openai.api_key", _SECRET)])+ assert (+ _bulk_value(manager, "llm.openai.api_key")+ == DataSanitizer.REDACTION_TEXT+ )+++def test_json_list_of_dicts_leaf_does_not_leak_secret():+ """A JSON list-of-dicts setting must not ship nested secrets via bulk.++ A ``ui_element="json"`` setting round-trips as an actual list, so+ redaction has to recurse into list items, not just dicts.+ """+ engine = create_engine("sqlite:///:memory:")+ Base.metadata.create_all(engine)+ session = sessionmaker(bind=engine)()+ session.add(+ Setting(+ key="mcp.servers",+ value=[{"name": "prod", "api_key": _SECRET}],+ type="app",+ name="mcp.servers",+ ui_element="json",+ )+ )+ session.commit()+ manager = SettingsManager(db_session=session)++ shipped = _bulk_value(manager, "mcp.servers")++ assert _SECRET not in str(shipped)+ assert shipped[0]["api_key"] == DataSanitizer.REDACTION_TEXT+ assert shipped[0]["name"] == "prod"