From 3479a021196ada78ab3fa71757a2f0292f49527d Mon Sep 17 00:00:00 2001 From: Chris Clark Date: Thu, 29 Oct 2026 09:13:45 -0400 Subject: [PATCH] Stop connection extras from overriding the computed connection DatabaseConnection.extras is free-form JSON entered by whoever manages the connection, and it was merged into the connection settings after the computed ones. For an upload-backed connection that meant extras["NAME"] won over the tenant's own local copy of their uploaded SQLite file: NAME -> user_dbs/ so one user could point an upload connection at another user's database by naming its path. HOST, USER and PASSWORD could be replaced the same way, and those are decrypted from the encrypted model fields that had just been used to compute the settings. ENGINE could be swapped too, which changes which driver is loaded. Keys that Explorer manages are now dropped from extras rather than merged: ENGINE always, and NAME/HOST/USER/PASSWORD additionally for uploads. The upload path stays pinned to uploaded_db_local_path(name), which is derived from the connection's own name in the shared user_dbs directory. Everything else in extras keeps working (OPTIONS, TIME_ZONE, ...). The keys are per-connection policy, so the filter lives on the model rather than in any single caller. --- HISTORY.rst | 6 +++ explorer/ee/db_connections/models.py | 24 ++++++++- explorer/tests/test_db_connection_utils.py | 58 ++++++++++++++++++++++ 3 files changed, 87 insertions(+), 1 deletion(-) diff --git a/HISTORY.rst b/HISTORY.rst index 75e7a307..3bd088ae 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -7,6 +7,12 @@ This project adheres to `Semantic Versioning `_. Unreleased =========================== +* **Security fix.** ``DatabaseConnection.extras`` is free-form JSON merged into the connection + settings *after* the computed ones, so for an uploaded connection it could override ``NAME`` and + point the connection at another user's database file, or replace the ``USER``/``PASSWORD``/``HOST`` + that were decrypted from the model. ``ENGINE``, and for uploads ``NAME``/``HOST``/``USER``/``PASSWORD``, + can no longer be set through ``extras``; a warning is logged when they are ignored. + * `#722`_: The query list (home page) no longer loads the entire query log history on every view. Run counts and last runs are computed in SQL, so the page stays fast as logs accumulate (300k logs: ~9.7s -> ~0.9s). The query list and query log pages also no longer run an extra database query per row. diff --git a/explorer/ee/db_connections/models.py b/explorer/ee/db_connections/models.py index 969e8c64..5699f5c4 100644 --- a/explorer/ee/db_connections/models.py +++ b/explorer/ee/db_connections/models.py @@ -169,7 +169,7 @@ def as_django_connection(self): if self.extras: extras_dict = json.loads(self.extras) if isinstance(self.extras, str) else self.extras - connection_settings.update(extras_dict) + connection_settings.update(self._allowed_extras(extras_dict)) try: backend = load_backend(self.engine) @@ -180,6 +180,28 @@ def as_django_connection(self): except DatabaseError as e: raise DatabaseError(f"Failed to create explorer connection: {e}") from e + def _allowed_extras(self, extras_dict): + """ + Drop the keys that would re-point this connection at the wrong database. + + ``extras`` is free-form JSON entered by whoever manages the connection, and it is + merged *after* the computed settings. For an upload-backed connection that means + ``NAME`` would win over the tenant's own local copy of their uploaded SQLite file, + letting one user read another user's database by naming its path -- or point + ``HOST``/``USER``/``PASSWORD`` somewhere unrelated, since those are decrypted from + the encrypted model fields into the settings above. + """ + pinned = {"ENGINE"} + if self.is_upload: + pinned |= {"NAME", "HOST", "USER", "PASSWORD"} + ignored = pinned & set(extras_dict) + if ignored: + logger.warning( + f"Ignoring {sorted(ignored)} in extras for connection '{self.alias}': " + f"these are managed by Explorer." + ) + return {k: v for k, v in extras_dict.items() if k not in pinned} + def save(self, *args, **kwargs): # If this instance is marked as default, unset the default on all other instances if self.default: diff --git a/explorer/tests/test_db_connection_utils.py b/explorer/tests/test_db_connection_utils.py index ecd44852..34691565 100644 --- a/explorer/tests/test_db_connection_utils.py +++ b/explorer/tests/test_db_connection_utils.py @@ -82,6 +82,64 @@ def test_create_django_style_connection_with_extras(self, mock_load_backend): self.assertEqual(args[0]["sslmode"], "require") self.assertEqual(args[0]["connect_timeout"], 10) + @patch("explorer.ee.db_connections.models.load_backend") + @patch("explorer.utils.get_s3_bucket") + def test_upload_connection_name_cannot_be_overridden_by_extras(self, mock_get_s3_bucket, mock_load_backend): + # An upload's NAME is the tenant's own local copy of their file. extras is merged + # after the computed settings, so it must not be able to re-point it. + mock_load_backend.return_value = MagicMock() + conn = DatabaseConnection( + name="mine_1.db", + alias="mine", + engine=DatabaseConnection.SQLITE, + host="user_dbs/user_1/mine_1.db", + extras='{"NAME": "/tmp/other_tenant.db"}' + ) + conn.download_sqlite_if_needed = lambda: None + + conn.as_django_connection() + + settings_dict = mock_load_backend.return_value.DatabaseWrapper.call_args[0][0] + self.assertEqual(settings_dict["NAME"], conn.local_name) + self.assertNotIn("other_tenant", settings_dict["NAME"]) + + @patch("explorer.ee.db_connections.models.load_backend") + @patch("explorer.utils.get_s3_bucket") + def test_upload_connection_credentials_cannot_be_overridden_by_extras(self, mock_get_s3_bucket, mock_load_backend): + mock_load_backend.return_value = MagicMock() + conn = DatabaseConnection( + name="mine_1.db", + alias="mine", + engine=DatabaseConnection.SQLITE, + host="user_dbs/user_1/mine_1.db", + user="real_user", + extras='{"USER": "someone_else", "PASSWORD": "stolen", "HOST": "evil.example.com"}' + ) + conn.download_sqlite_if_needed = lambda: None + + conn.as_django_connection() + + settings_dict = mock_load_backend.return_value.DatabaseWrapper.call_args[0][0] + self.assertEqual(settings_dict["USER"], "real_user") + self.assertIsNone(settings_dict["HOST"]) + self.assertNotEqual("stolen", settings_dict["PASSWORD"]) + + @patch("explorer.ee.db_connections.models.load_backend") + def test_extras_still_apply_to_non_upload_connections(self, mock_load_backend): + # Something like OPTIONS is legitimate and must keep working. + mock_load_backend.return_value = MagicMock() + conn = DatabaseConnection( + name="mydb", + alias="mydb", + engine="django.db.backends.postgresql", + extras='{"OPTIONS": {"sslmode": "require"}}' + ) + + conn.as_django_connection() + + options = mock_load_backend.return_value.DatabaseWrapper.call_args[0][0]["OPTIONS"] + self.assertEqual(options, {"sslmode": "require"}) + @skipIf(not EXPLORER_USER_UPLOADS_ENABLED, "User uploads not enabled") class TestPandasToSQLite(TestCase):