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: stop /settings/api/bulk leaking nested plaintext secrets (#5028)

LearningCircuit8af91a4ea9e3
diff --git a/changelog.d/5028.security.md b/changelog.d/5028.security.md
new file mode 100644
index 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.py
index 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 so
the UI can tell "configured" from "not configured" without leaking
that 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
@staticmethod
diff --git a/src/local_deep_research/settings/manager.py b/src/local_deep_research/settings/manager.py
index 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 Session
from .. import defaults
from ..__version__ import __version__ as package_version
from ..database.models import Setting, SettingType
+from ..utilities.sql_utils import escape_like
from ..utilities.type_utils import to_bool
from ..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.py
index 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 original
assert 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_TEXT
diff --git a/tests/security/test_settings_bulk_secret_leak.py b/tests/security/test_settings_bulk_secret_leak.py
new file mode 100644
index 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"