You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by jl...@apache.org on 2026/07/01 17:12:08 UTC
(superset) 01/02: Merge remote-tracking branch 'origin/master' into claude/subdirectory-helpers-tdd
This is an automated email from the ASF dual-hosted git repository.
sadpandajoe pushed a commit to branch claude/subdirectory-helpers-tdd
in repository https://gitbox.apache.org/repos/asf/superset.git
commit 61f36b019fb0654e5b43074974dc497e5d4ad02e
Merge: 720521e703f 6d2b94ceb80
Author: Joe Li <jo...@preset.io>
AuthorDate: Wed Jul 1 09:43:39 2026 -0700
Merge remote-tracking branch 'origin/master' into claude/subdirectory-helpers-tdd
# Conflicts:
# UPDATING.md
# superset-frontend/src/utils/navigationUtils.test.ts
# superset-frontend/src/utils/navigationUtils.ts
# superset/translations/ja/LC_MESSAGES/messages.po
.github/actions/setup-supersetbot/action.yml | 2 +
.github/workflows/bump-python-package.yml | 2 +-
.github/workflows/generate-FOSSA-report.yml | 2 +-
.github/workflows/github-action-validator.yml | 4 +-
.github/workflows/license-check.yml | 2 +-
.github/workflows/pre-commit.yml | 2 +-
.github/workflows/release.yml | 4 +-
.github/workflows/superset-docs-deploy.yml | 2 +-
.github/workflows/superset-helm-lint.yml | 2 +-
.github/workflows/superset-helm-release.yml | 2 +-
UPDATING.md | 43 +
.../configuration/configuring-superset.mdx | 18 +
docs/package.json | 8 +-
docs/static/feature-flags.json | 6 +
docs/yarn.lock | 174 +-
pyproject.toml | 2 +-
requirements/base.txt | 2 +-
requirements/development.txt | 2 +-
.../translations/check_translation_regression.py | 229 +-
superset-embedded-sdk/babel.config.js | 1 +
superset-embedded-sdk/package.json | 2 +-
superset-embedded-sdk/tsconfig.json | 1 +
superset-frontend/package-lock.json | 16 +-
superset-frontend/package.json | 2 +-
.../src/chart/components/StatefulChart.tsx | 3 +-
.../src/components/AsyncEsmComponent/index.tsx | 10 +-
.../DropdownContainer/DropdownContainer.tsx | 4 +-
.../src/components/Icons/AntdEnhanced.tsx | 13 +-
.../src/components/ModalTrigger/index.tsx | 20 +-
.../src/components/Select/AsyncSelect.tsx | 74 +-
.../src/components/Select/Select.tsx | 62 +-
.../src/components/Table/VirtualTable.tsx | 4 +-
.../Table/utils/InteractiveTableUtils.ts | 2 +-
.../src/components/TableCollection/index.tsx | 18 +-
.../src/components/TimezoneSelector/index.tsx | 12 +-
.../superset-ui-core/src/connection/types.ts | 12 +-
.../src/currency-format/CurrencyFormatter.ts | 38 +-
.../src/currency-format/currencyLocale.ts | 52 +
.../superset-ui-core/src/currency-format/index.ts | 6 +
.../src/currency-format/symbolPosition.ts | 93 +
.../src/time-comparison/fetchTimeRange.ts | 10 +-
.../superset-ui-core/src/utils/lruCache.ts | 7 +-
.../test/currency-format/CurrencyFormatter.test.ts | 52 +-
.../test/currency-format/currencyLocale.test.ts | 65 +
.../test/currency-format/symbolPosition.test.ts | 74 +
.../packages/superset-ui-core/types/assets.d.ts | 1 +
.../src/components/ScatterPlotOverlay.tsx | 8 +-
.../test/ScatterPlotOverlay.test.tsx | 52 +-
.../src/components/GridTable/index.tsx | 18 +
.../EmbeddedModal/EmbeddedModal.test.tsx | 12 +
.../dashboard/components/EmbeddedModal/index.tsx | 2 +-
.../DetailsPanel/DetailsPanel.test.tsx | 17 +
.../dashboard/components/FiltersBadge/Styles.tsx | 12 +
.../dashboard/components/Header/Header.test.tsx | 28 +
.../src/dashboard/components/Header/index.tsx | 4 +-
.../SliceHeaderControls.test.tsx | 112 +
.../components/SliceHeaderControls/index.tsx | 15 +-
.../src/setup/setupFormatters.test.ts | 71 +
superset-frontend/src/setup/setupFormatters.ts | 5 +
.../src/utils/navigationUtils.test.ts | 54 +
superset-frontend/src/utils/navigationUtils.ts | 32 +-
superset/async_events/async_query_manager.py | 16 +-
superset/commands/report/execute.py | 14 +-
superset/commands/sql_lab/estimate.py | 79 +-
superset/config.py | 67 +-
superset/daos/base.py | 15 +-
superset/daos/dashboard.py | 31 +-
superset/mcp_service/app.py | 14 +-
superset/mcp_service/dashboard/schemas.py | 705 +++++-
superset/mcp_service/dashboard/tool/__init__.py | 8 +
.../dashboard/tool/duplicate_dashboard.py | 427 ++++
.../dashboard/tool/get_dashboard_datasets.py | 156 ++
.../dashboard/tool/manage_native_filters.py | 513 +++++
.../dashboard/tool/remove_chart_from_dashboard.py | 540 +++++
.../mcp_service/dashboard/tool/update_dashboard.py | 148 +-
.../mcp_service/docs/tool-search-optimization.md | 2 +-
superset/mcp_service/mcp_config.py | 1 +
superset/mcp_service/middleware.py | 1 +
superset/models/core.py | 40 +
superset/models/helpers.py | 87 +-
superset/sql/execution/executor.py | 62 +-
superset/sql/parse.py | 275 ++-
superset/sql_lab.py | 35 +-
superset/translations/ja/LC_MESSAGES/messages.po | 2309 +++++++++++---------
tests/integration_tests/email_tests.py | 12 +-
.../async_events/async_query_manager_tests.py | 53 +
tests/unit_tests/commands/sql_lab/test_estimate.py | 78 +-
tests/unit_tests/config_test.py | 120 +
tests/unit_tests/daos/test_base_dao_soft_delete.py | 50 +-
.../dashboard/test_dashboard_schemas.py | 70 +
.../dashboard/tool/test_duplicate_dashboard.py | 645 ++++++
.../dashboard/tool/test_get_dashboard_datasets.py | 388 ++++
.../dashboard/tool/test_manage_native_filters.py | 818 +++++++
.../tool/test_remove_chart_from_dashboard.py | 724 ++++++
.../dashboard/tool/test_update_dashboard.py | 198 +-
tests/unit_tests/models/core_test.py | 39 +
tests/unit_tests/models/helpers_test.py | 55 +
tests/unit_tests/models/test_soft_delete_mixin.py | 38 +
.../check_translation_regression_test.py | 160 ++
tests/unit_tests/sql/execution/test_executor.py | 86 +-
tests/unit_tests/sql/parse_tests.py | 562 +++++
101 files changed, 9766 insertions(+), 1479 deletions(-)
diff --cc UPDATING.md
index ef015443e81,ab5994402bc..8432631c244
--- a/UPDATING.md
+++ b/UPDATING.md
@@@ -24,23 -24,27 +24,45 @@@ assists people when migrating to a new
## Next
+- [39925](https://github.com/apache/superset/pull/39925): URL prefixing for `SUPERSET_APP_ROOT` subdirectory deployments is now handled automatically by helpers in `src/utils/navigationUtils` (`openInNewTab`, `redirect`, `getShareableUrl`, `<AppLink>`). Direct imports of `ensureAppRoot` / `makeUrl` from `src/utils/pathUtils` are forbidden outside `navigationUtils.ts` (enforced by a static-invariant test); contributors writing new code should use the focused helpers instead. No runtime b [...]
+
+- [39925](https://github.com/apache/superset/pull/39925): `SupersetClient.getUrl()` now strips a single leading application-root segment from the supplied `endpoint` before building the request URL, so a caller that accidentally pre-prefixes its endpoint (for example by wrapping it with `ensureAppRoot` before passing it to the client) no longer produces a doubled `/superset/superset/...` URL under subdirectory deployment. The strip is **single-pass** — a genuine `/superset/superset/<slu [...]
+
+- **Breaking — `Superset` view class route prefix removed.** The `Superset` view in `superset/views/core.py` now declares `route_base = ""`, overriding Flask-AppBuilder's auto-derived `/superset` prefix. Routes that previously lived at `/superset/welcome/`, `/superset/dashboard/<id>/`, `/superset/dashboard/p/<key>/`, `/superset/explore/`, etc. now respond at `/welcome/`, `/dashboard/<id>/`, `/dashboard/p/<key>/`, `/explore/`, etc. Under subdirectory deployment (`SUPERSET_APP_ROOT=/super [...]
+
+- **Breaking — Three sibling view classes route prefix removed.** Following the same rationale as the `Superset` class above, `ExplorePermalinkView` (`superset/views/explore.py`), `TagModelView`, and `TaggedObjectsModelView` (`superset/views/tags.py`, `superset/views/all_entities.py`) now mount at the application root rather than a hard-coded `/superset/...`. The user-visible URLs `/superset/explore/p/<key>/`, `/superset/tags/`, and `/superset/all_entities/` are unchanged under subdirec [...]
+
+- **Legacy `/superset/*` path support.** A new outermost WSGI middleware `LegacyPrefixRedirectMiddleware` (`superset/middleware/legacy_prefix_redirect.py`) 308-redirects every enumerated legacy `/superset/<canonical>` path to its post-`route_base=""` canonical location (e.g. `/superset/welcome/` → `/welcome/` under root; → `/superset/welcome/` under `SUPERSET_APP_ROOT=/superset`, because the canonical resolves through `AppRootMiddleware`). Bookmarks, email links, and external integratio [...]
+
+- **PWA web app manifest served dynamically.** The PWA manifest is now served at `/pwa-manifest.json` (under `APPLICATION_ROOT`) by a new `PwaManifestView` (`superset/views/pwa_manifest.py`) instead of the static file at `/static/assets/pwa-manifest.json`. The legacy static source at `superset-frontend/src/pwa-manifest.json` has been removed (along with its `webpack.config.js` `CopyPlugin` rule). The new endpoint resolves `APPLICATION_ROOT` and `STATIC_ASSETS_PREFIX` at request time so [...]
+
+- **Hard re-bookmark break — `/superset/sql/<database_id>/`.** SQL Lab moved to its own blueprint at `/sqllab/`. The legacy `/superset/sql/<id>/` shape changed to a query-string form (`/sqllab/?dbid=<id>`); no 1:1 path mapping exists, so `LegacyPrefixRedirectMiddleware` does **not** redirect this route — it passes through and surfaces a 404. Users with bookmarks to `/superset/sql/<id>/` must update them to `/sqllab/?dbid=<id>`.
+
+- **`SqlaTable.sql_url` query-string format.** `SqlaTable.sql_url` now URL-encodes `table_name` and joins it as a query parameter rather than concatenating a second `?`. Previously, with `Database.sql_url` returning `/sqllab/?dbid=<id>`, the concatenation produced `/sqllab/?dbid=<id>?table_name=<raw>` — a malformed second `?` that broke the query parser. External code that parsed the legacy `<base>?table_name=<raw>` shape now sees properly percent-encoded values (e.g. `/` → `%2F`, ` ` → [...]
+
+- **New config flag `EMBEDDED_DISABLE_PERMALINK_ORIGIN_REWRITE` (default `False`).** Share/permalink URLs now substitute `window.location.origin` for the backend-supplied origin so a proxied or subdirectory-deployed Superset never hands the user an unreachable internal hostname. Operators whose reverse proxy correctly forwards `X-Forwarded-Host` *and* who want permalinks to carry the backend's literal origin can opt out by setting `EMBEDDED_DISABLE_PERMALINK_ORIGIN_REWRITE = True` in `s [...]
++
+ ### SQL Lab denies large-object and information_schema access by default
+
+ `DISALLOWED_SQL_FUNCTIONS` and `DISALLOWED_SQL_TABLES` now ship with additional default entries, so SQL Lab and chart-data queries that reference them are rejected where they were previously allowed:
+
+ - PostgreSQL large-object routines (`lo_from_bytea`, `lo_export`, `lo_import`, `lo_put`, `lo_create`, `lo_creat`, `lowrite`, `lo_get`, `loread`, `lo_unlink`), which read and write bytes on the database server's filesystem.
+ - The SQL-standard `information_schema` views (`tables`, `columns`, `routines`, `views`, the privilege/grant views, etc.), which expose table, column, privilege, and view-definition metadata across the whole database.
+
+ Deployments that legitimately query these (for example tooling that introspects `information_schema`) can restore the previous behavior by overriding `DISALLOWED_SQL_FUNCTIONS` / `DISALLOWED_SQL_TABLES` in `superset_config.py` to drop the entries they need.
+
+ Because the denylist now resolves the effective schema through the query-aware path, PostgreSQL queries that change the `search_path` (e.g. `SET search_path = ...`) are rejected on the SQL Lab execution and cost-estimate paths whenever any `DISALLOWED_SQL_TABLES` entry is configured (the default for PostgreSQL), matching the behavior previously applied only when `RLS_IN_SQLLAB` was enabled.
+
+ ### SQL parser input length cap (SQL_MAX_PARSE_LENGTH)
+
+ The SQL parser now rejects scripts whose UTF-8 byte length exceeds the new
+ `SQL_MAX_PARSE_LENGTH` config option (default `1_000_000` bytes) before they are
+ handed to sqlglot, which bounds parser memory and CPU usage. A single query
+ larger than the cap (for example a very large `IN (...)` list or a big
+ virtual-dataset SQL) raises a parse error in SQL Lab and dashboard-generated
+ queries. Deployments that legitimately run queries above this size should raise
+ the value, and `SQL_MAX_PARSE_LENGTH = None` disables the check entirely.
+
### Guest-token RLS rules reject unknown fields
The `rls` rules passed to `POST /api/v1/security/guest_token/` are now validated strictly: a rule may only contain `dataset` and `clause`. Previously unknown fields were silently dropped, so a mistyped or legacy scope key (most commonly `datasource` instead of `dataset`) produced a rule with no `dataset`, which is treated as a *global* rule applied to every dataset the embedded resource can reach. Such a request now returns HTTP 400 identifying the offending field instead of issuing a t [...]
diff --cc superset-frontend/src/utils/navigationUtils.test.ts
index 60c1b500ac7,eea2a910843..39f35ee7e8a
--- a/superset-frontend/src/utils/navigationUtils.test.ts
+++ b/superset-frontend/src/utils/navigationUtils.test.ts
@@@ -16,711 -16,48 +16,765 @@@
* specific language governing permissions and limitations
* under the License.
*/
-jest.mock('./pathUtils', () => ({
- ensureAppRoot: (url: string) => url,
-}));
-
-let navigateTo: typeof import('./navigationUtils').navigateTo;
-let assignMock: jest.Mock;
-let locationSpy: jest.SpyInstance;
-
-beforeEach(async () => {
- jest.resetModules();
- jest.useFakeTimers();
- ({ navigateTo } = await import('./navigationUtils'));
- assignMock = jest.fn();
- locationSpy = jest
- .spyOn(window, 'location', 'get')
- .mockReturnValue({ ...window.location, assign: assignMock } as Location);
+import { withApplicationRoot } from 'spec/helpers/withApplicationRoot';
+
+// Surface any future hang as a Jest timeout instead of stalling CI.
+jest.setTimeout(20000);
+
+describe('openInNewTab', () => {
+ let openSpy: jest.SpyInstance;
+
+ beforeEach(() => {
+ openSpy = jest.spyOn(window, 'open').mockImplementation(() => null);
+ });
+
+ afterEach(() => {
+ openSpy.mockRestore();
+ });
+
+ test('passes router-relative path through unchanged when application root is empty', async () => {
+ await withApplicationRoot('', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ openInNewTab('/sqllab?new=true');
+ expect(openSpy).toHaveBeenCalledWith(
+ '/sqllab?new=true',
+ '_blank',
+ 'noopener noreferrer',
+ );
+ });
+ });
+
+ test('prefixes router-relative path with application root under subdirectory deployment', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ openInNewTab('/sqllab?new=true');
+ expect(openSpy).toHaveBeenCalledWith(
+ '/superset/sqllab?new=true',
+ '_blank',
+ 'noopener noreferrer',
+ );
+ });
+ });
+
+ test('prefixes correctly for nested subdirectory roots', async () => {
+ await withApplicationRoot('/a/b/c/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ openInNewTab('/dashboard/list');
+ expect(openSpy).toHaveBeenCalledWith(
+ '/a/b/c/dashboard/list',
+ '_blank',
+ 'noopener noreferrer',
+ );
+ });
+ });
+
+ test('passes absolute URLs through unchanged regardless of application root', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ openInNewTab('https://external.example.com/docs');
+ expect(openSpy).toHaveBeenCalledWith(
+ 'https://external.example.com/docs',
+ '_blank',
+ 'noopener noreferrer',
+ );
+ });
+ });
+
+ test('passes mailto: URLs through unchanged', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ openInNewTab('mailto:owner@example.com');
+ expect(openSpy).toHaveBeenCalledWith(
+ 'mailto:owner@example.com',
+ '_blank',
+ 'noopener noreferrer',
+ );
+ });
+ });
+
+ test('uses noopener noreferrer for security on every call', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ openInNewTab('/sqllab');
+ expect(openSpy).toHaveBeenCalledTimes(1);
+ const features = openSpy.mock.calls[0][2] as string;
+ expect(features).toContain('noopener');
+ expect(features).toContain('noreferrer');
+ });
+ });
+
+ test('refuses protocol-relative URLs to block open-redirect via `//evil.com`', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ expect(() => openInNewTab('//evil.example.com/phish')).toThrow(
+ /refused unsafe URL/,
+ );
+ expect(openSpy).not.toHaveBeenCalled();
+ });
+ });
+
+ // Scheme-without-authority bypass. WHATWG
+ // URL parsers extract the host from `http:evil.com/foo` as `evil.com`,
+ // so the previous regex `/^https?:/i` mistook a cross-origin URL for a
+ // safe absolute one. The tightened regex requires `//` after the scheme.
+ test.each([
+ ['http:evil.example.com/phish'],
+ ['https:evil.example.com/phish'],
+ ['HTTP:evil.example.com/phish'],
+ ['ftp:evil.example.com/file'],
+ ])('refuses scheme-without-authority URL %s', async (unsafeUrl: string) => {
+ await withApplicationRoot('/superset/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ expect(() => openInNewTab(unsafeUrl)).toThrow(/refused unsafe URL/);
+ expect(openSpy).not.toHaveBeenCalled();
+ });
+ });
+
+ // C0/C1 controls and zero-width / bidi
+ // formatting marks are stripped by browsers before URL parsing, so a
+ // string like `\t//evil.com` would survive the leading-slash check and
+ // navigate cross-origin. Reject them outright.
+ test.each([
+ ['\t//evil.example.com'],
+ ['\n//evil.example.com'],
+ ['\r//evil.example.com'],
+ ['/foo'],
+ ['/foo'],
+ ['/foo'],
+ ])(
+ 'refuses URL %j containing control or zero-width chars',
+ async (unsafeUrl: string) => {
+ await withApplicationRoot('/superset/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ expect(() => openInNewTab(unsafeUrl)).toThrow(/refused unsafe URL/);
+ expect(openSpy).not.toHaveBeenCalled();
+ });
+ },
+ );
+
+ // The bidi formatting
+ // ranges U+202A..U+202E (LRE/RLE/PDF/LRO/RLO) and U+2066..U+2069
+ // (LRI/RLI/FSI/PDI) were promised by the earlier comment but missing from
+ // the original regex. Pin them directly so a documentation/regex drift
+ // can't reintroduce the gap.
+ test.each([
+ ['/foo', 'U+202A LRE'],
+ ['/foo', 'U+202B RLE'],
+ ['/foo', 'U+202C PDF'],
+ ['/foo', 'U+202D LRO'],
+ ['/foo', 'U+202E RLO'],
+ ['/foo', 'U+2066 LRI'],
+ ['/foo', 'U+2067 RLI'],
+ ['/foo', 'U+2068 FSI'],
+ ['/foo', 'U+2069 PDI'],
+ ])(
+ 'refuses URL containing %s bidi formatting mark',
+ async (unsafeUrl: string, _label: string) => {
+ await withApplicationRoot('/superset/', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ expect(() => openInNewTab(unsafeUrl)).toThrow(/refused unsafe URL/);
+ expect(openSpy).not.toHaveBeenCalled();
+ });
+ },
+ );
});
-afterEach(() => {
- locationSpy.mockRestore();
- jest.useRealTimers();
+describe('redirect', () => {
+ let originalLocation: Location;
+
+ beforeEach(() => {
+ originalLocation = window.location;
+ delete (window as unknown as { location?: Location }).location;
+ (window as unknown as { location: { href: string } }).location = {
+ href: '',
+ } as Location;
+ });
+
+ afterEach(() => {
+ (window as unknown as { location: Location }).location = originalLocation;
+ });
+
+ test('sets window.location.href to the unprefixed path under empty root', async () => {
+ await withApplicationRoot('', async () => {
+ const { redirect } = await import('src/utils/navigationUtils');
+ redirect('/');
+ expect(window.location.href).toBe('/');
+ });
+ });
+
+ test('prefixes the path under a subdirectory deployment', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { redirect } = await import('src/utils/navigationUtils');
+ redirect('/');
+ expect(window.location.href).toBe('/superset/');
+ });
+ });
+
+ test('passes absolute URLs through unchanged', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { redirect } = await import('src/utils/navigationUtils');
+ redirect('https://external.example.com/foo');
+ expect(window.location.href).toBe('https://external.example.com/foo');
+ });
+ });
+
+ // encodeURI-at-the-sink regression: see the
+ // matching navigateWithState tests — `%27`/`%20` must survive un-doubled.
+ test('does not double-encode percent-encoded query strings', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { redirect } = await import('src/utils/navigationUtils');
+ redirect('/dashboard/list/?filters=(label:%27a%20b%27)');
+ expect(window.location.href).toBe(
+ '/superset/dashboard/list/?filters=(label:%27a%20b%27)',
+ );
+ });
+ });
+
+ // Backslash-laden URLs
+ // were accepted by `SAFE_NAVIGATION_URL_RE` and the sibling guards in
+ // `ensureAppRoot` / `isAllowedScheme`. Browsers normalise `/\` → `//` in
+ // the special-scheme authority, so `/\evil.com` became a cross-origin
+ // navigation. The hardened guard must reject these *before* nav, and
+ // `redirect` (which routes through `navigateTo`) must fall back to `/`
+ // with a `console.error` rather than navigating to the unsafe target.
+
+ test.each([
+ ['empty app root', ''],
+ ['/superset app root', '/superset/'],
+ ])(
+ 'falls back to "/" + console.error for /\\evil.com under %s',
+ async (_label, appRoot) => {
+ await withApplicationRoot(appRoot, async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { redirect } = await import('src/utils/navigationUtils');
+ redirect('/\\evil.com');
+ // Fall back to ensureAppRoot('/') under the active root.
+ expect(window.location.href).toBe(
+ appRoot === '' ? '/' : '/superset/',
+ );
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ },
+ );
+
+ test('falls back to "/" + console.error for https://good@evil.com (userinfo)', async () => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { redirect } = await import('src/utils/navigationUtils');
+ redirect('https://good@evil.example.com/path');
+ expect(window.location.href).toBe('/');
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ });
+
+ test('falls back to "/" + console.error for //evil.com (already-blocked regression)', async () => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { redirect } = await import('src/utils/navigationUtils');
+ redirect('//evil.example.com');
+ expect(window.location.href).toBe('/');
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ });
+
+ // Scheme-without-authority bypass on the full-page-nav path. WHATWG URL
+ // parsers extract the host from `http:evil.com/foo` as `evil.com`, so the
+ // external-URL branch's bare `parsed.protocol === 'http:'` check mistook a
+ // cross-origin URL for a safe absolute one. `openInNewTab` already rejected
+ // this shape; `redirect` (→ `navigateTo`) must too, falling back to `/`
+ // with a `console.error` rather than following the cross-origin target.
+ test.each([
+ ['http:evil.example.com/phish'],
+ ['https:evil.example.com/phish'],
+ ['HTTP:evil.example.com/phish'],
+ ['ftp:evil.example.com/file'],
+ ])(
+ 'falls back to "/" + console.error for scheme-without-authority URL %s',
+ async (unsafeUrl: string) => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { redirect } = await import('src/utils/navigationUtils');
+ redirect(unsafeUrl);
+ expect(window.location.href).toBe('/');
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ },
+ );
});
-test('ignores a repeated assign to the same URL within the dedupe window', () => {
- navigateTo('/dashboard/new', { assign: true });
- navigateTo('/dashboard/new', { assign: true });
+// `navigateTo` and `navigateWithState` are exported imperative helpers
+// and are the entry points that these tests cover.
+describe('navigateTo', () => {
+ let originalLocation: Location;
+ let openSpy: jest.SpyInstance;
+
+ beforeEach(() => {
+ originalLocation = window.location;
+ delete (window as unknown as { location?: Location }).location;
+ (
+ window as unknown as {
+ location: { href: string; assign: jest.Mock };
+ }
+ ).location = {
+ href: '',
+ assign: jest.fn(),
+ };
+ openSpy = jest.spyOn(window, 'open').mockImplementation(() => null);
+ });
+
+ afterEach(() => {
+ (window as unknown as { location: Location }).location = originalLocation;
+ openSpy.mockRestore();
+ });
+
+ test('falls back to "/" + console.error for /\\evil.com (default href)', async () => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { navigateTo } = await import('src/utils/navigationUtils');
+ navigateTo('/\\evil.com');
+ expect(window.location.href).toBe('/');
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ });
+
+ test('falls back to "/" + console.error for /\\evil.com (newWindow path)', async () => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { navigateTo } = await import('src/utils/navigationUtils');
+ navigateTo('/\\evil.com', { newWindow: true });
+ // window.open never called with the unsafe URL; fallback to href='/'
+ expect(openSpy).not.toHaveBeenCalledWith(
+ expect.stringContaining('\\evil.com'),
+ expect.anything(),
+ expect.anything(),
+ );
+ expect(window.location.href).toBe('/');
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ });
+
+ // Scheme-without-authority bypass: `new URL('http:evil.com/foo')` resolves
+ // the host to `evil.com`, so the external-URL branch must require an
+ // explicit `//` after the scheme (mirroring `SAFE_NAVIGATION_URL_RE`) and
+ // fall back to `/` rather than navigating cross-origin.
+ test.each([
+ ['http:evil.example.com/phish'],
+ ['https:evil.example.com/phish'],
+ ['HTTP:evil.example.com/phish'],
+ ['ftp:evil.example.com/file'],
+ ])(
+ 'falls back to "/" + console.error for scheme-without-authority URL %s',
+ async (unsafeUrl: string) => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { navigateTo } = await import('src/utils/navigationUtils');
+ navigateTo(unsafeUrl);
+ expect(window.location.href).toBe('/');
+ expect(openSpy).not.toHaveBeenCalled();
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ },
+ );
+
+ test('refuses scheme-without-authority URL on the newWindow path', async () => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { navigateTo } = await import('src/utils/navigationUtils');
+ navigateTo('http:evil.example.com/phish', { newWindow: true });
+ expect(openSpy).not.toHaveBeenCalled();
+ expect(window.location.href).toBe('/');
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ });
- expect(assignMock).toHaveBeenCalledTimes(1);
- expect(assignMock).toHaveBeenCalledWith('/dashboard/new');
+ test('passes legitimate router-relative path through unchanged', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { navigateTo } = await import('src/utils/navigationUtils');
+ navigateTo('/dashboard/list/');
+ expect(window.location.href).toBe('/superset/dashboard/list/');
+ });
+ });
+
+ test('uses window.location.assign (not href) for a router-relative path when { assign: true }', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { navigateTo } = await import('src/utils/navigationUtils');
+ navigateTo('/dashboard/list/', { assign: true });
+ expect(window.location.assign).toHaveBeenCalledWith(
+ '/superset/dashboard/list/',
+ );
+ // The assign branch must not also fall through to the href sink.
+ expect(window.location.href).toBe('');
+ });
+ });
+
+ test('uses window.location.assign for an external URL when { assign: true }', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { navigateTo } = await import('src/utils/navigationUtils');
+ navigateTo('https://external.example.com/docs', { assign: true });
+ expect(window.location.assign).toHaveBeenCalledWith(
+ 'https://external.example.com/docs',
+ );
+ expect(window.location.href).toBe('');
+ });
+ });
+});
+
+describe('navigateWithState', () => {
+ let pushSpy: jest.SpyInstance;
+ let replaceSpy: jest.SpyInstance;
+
+ beforeEach(() => {
+ pushSpy = jest
+ .spyOn(window.history, 'pushState')
+ .mockImplementation(() => {});
+ replaceSpy = jest
+ .spyOn(window.history, 'replaceState')
+ .mockImplementation(() => {});
+ });
+
+ afterEach(() => {
+ pushSpy.mockRestore();
+ replaceSpy.mockRestore();
+ });
+
+ test('no-ops + console.error for /\\evil.com (does NOT trigger full-page nav)', async () => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/\\evil.com', { from: 'test' });
+ expect(pushSpy).not.toHaveBeenCalled();
+ expect(replaceSpy).not.toHaveBeenCalled();
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ });
+
+ // Scheme-without-authority bypass on the history-API path: the external-URL
+ // branch must reject `http:evil.com/foo` (host normalises to `evil.com`)
+ // and no-op rather than pushing a cross-origin URL into history.
+ test.each([
+ ['http:evil.example.com/phish'],
+ ['https:evil.example.com/phish'],
+ ['HTTP:evil.example.com/phish'],
+ ['ftp:evil.example.com/file'],
+ ])(
+ 'no-ops + console.error for scheme-without-authority URL %s',
+ async (unsafeUrl: string) => {
+ await withApplicationRoot('', async () => {
+ const errorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ try {
+ const { navigateWithState } =
+ await import('src/utils/navigationUtils');
+ navigateWithState(unsafeUrl, { from: 'test' });
+ expect(pushSpy).not.toHaveBeenCalled();
+ expect(replaceSpy).not.toHaveBeenCalled();
+ expect(errorSpy).toHaveBeenCalled();
+ } finally {
+ errorSpy.mockRestore();
+ }
+ });
+ },
+ );
+
+ test('passes legitimate router-relative path through to pushState', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/dashboard/42/', { from: 'test' });
+ expect(pushSpy).toHaveBeenCalledWith(
+ { from: 'test' },
+ '',
+ '/superset/dashboard/42/',
+ );
+ });
+ });
+
+ test('uses replaceState (not pushState) when { replace: true }', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/dashboard/42/', { from: 'test' }, { replace: true });
+ expect(replaceSpy).toHaveBeenCalledWith(
+ { from: 'test' },
+ '',
+ '/superset/dashboard/42/',
+ );
+ expect(pushSpy).not.toHaveBeenCalled();
+ });
+ });
+
+ // encodeURI-at-the-sink regression: the CodeQL
+ // `js/html-injection` sanitiser escapes `%` itself, so already-percent-
+ // encoded paths (the URL constructor's output always is) were double-
+ // encoded — `%20` → `%2520` — corrupting the pushed URL.
+ test('does not double-encode percent-encoded rison paths (pushState)', async () => {
+ await withApplicationRoot('', async () => {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/dashboard/list/?filters=(label:%27a%20b%27)', {});
+ expect(pushSpy).toHaveBeenCalledWith(
+ {},
+ '',
+ '/dashboard/list/?filters=(label:%27a%20b%27)',
+ );
+ });
+ });
+
+ test('single-encodes raw spaces and unicode path segments (pushState)', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/dashboard/百分比 slug/', {});
+ expect(pushSpy).toHaveBeenCalledWith(
+ {},
+ '',
+ '/superset/dashboard/%E7%99%BE%E5%88%86%E6%AF%94%20slug/',
+ );
+ });
+ });
+
+ // Restore-regex corner cases (review follow-up on the encodeURI fix):
+ // pinned so a future "simplification" of DOUBLE_ENCODED_ESCAPE_RE (e.g.
+ // an uppercase-only hex class, or a greedy restore that collapses
+ // intentional `%25XX`) cannot pass the suite while corrupting URLs.
+ test('preserves intentionally double-encoded %2520 (pushState)', async () => {
+ await withApplicationRoot('', async () => {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/dashboard/list/?q=%2520', {});
+ expect(pushSpy).toHaveBeenCalledWith({}, '', '/dashboard/list/?q=%2520');
+ });
+ });
+
+ test('preserves literal %25 followed by hex (%25AB) (pushState)', async () => {
+ await withApplicationRoot('', async () => {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/dashboard/list/?q=%25AB', {});
+ expect(pushSpy).toHaveBeenCalledWith({}, '', '/dashboard/list/?q=%25AB');
+ });
+ });
+
+ test('preserves lowercase hex escapes (%2f) (pushState)', async () => {
+ await withApplicationRoot('', async () => {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/dashboard/a%2fb/', {});
+ expect(pushSpy).toHaveBeenCalledWith({}, '', '/dashboard/a%2fb/');
+ });
+ });
+
+ test('single-encodes an invalid percent sequence (%zz) (pushState)', async () => {
+ await withApplicationRoot('', async () => {
+ const { navigateWithState } = await import('src/utils/navigationUtils');
+ navigateWithState('/dashboard/100%zz/', {});
+ expect(pushSpy).toHaveBeenCalledWith({}, '', '/dashboard/100%25zz/');
+ });
+ });
});
-test('assigns different URLs in quick succession', () => {
- navigateTo('/dashboard/new', { assign: true });
- navigateTo('/chart/add', { assign: true });
+describe('getShareableUrl', () => {
+ test('returns origin + unprefixed path under empty root', async () => {
+ await withApplicationRoot('', async () => {
+ const { getShareableUrl } = await import('src/utils/navigationUtils');
+ expect(getShareableUrl('/sqllab?id=1')).toBe(
+ `${window.location.origin}/sqllab?id=1`,
+ );
+ });
+ });
+
+ test('returns origin + prefixed path under subdirectory deployment', async () => {
+ await withApplicationRoot('/superset/', async () => {
+ const { getShareableUrl } = await import('src/utils/navigationUtils');
+ expect(getShareableUrl('/sqllab?id=1')).toBe(
+ `${window.location.origin}/superset/sqllab?id=1`,
+ );
+ });
+ });
+
+ // Composition pin:
+ // `assertSafeNavigationUrl` is module-private; route the pin through the
+ // purest public helper. `getShareableUrl` runs the same composition
+ // (`assertSafeNavigationUrl(ensureAppRoot(...))`) as `openInNewTab` /
+ // `AppLink`, side-effect-free. Throwing here proves the guard runs
+ // post-`ensureAppRoot`, which is the invariant `pathUtils.ts:41` must
+ // preserve in lockstep.
+ test.each([
+ ['empty app root', ''],
+ ['/superset app root', '/superset/'],
+ ])(
+ 'throws for /\\evil.com under %s (composition pin)',
+ async (_label, appRoot) => {
+ await withApplicationRoot(appRoot, async () => {
+ const { getShareableUrl } = await import('src/utils/navigationUtils');
+ expect(() => getShareableUrl('/\\evil.com')).toThrow(
+ /refused unsafe URL/,
+ );
+ });
+ },
+ );
+
+ test('throws for //evil.com (already-blocked regression)', async () => {
+ await withApplicationRoot('', async () => {
+ const { getShareableUrl } = await import('src/utils/navigationUtils');
+ expect(() => getShareableUrl('//evil.example.com')).toThrow(
+ /refused unsafe URL/,
+ );
+ });
+ });
- expect(assignMock).toHaveBeenCalledTimes(2);
+ test('throws for https://good@evil.com (userinfo)', async () => {
+ await withApplicationRoot('', async () => {
+ const { getShareableUrl } = await import('src/utils/navigationUtils');
+ expect(() =>
+ getShareableUrl('https://good@evil.example.com/path'),
+ ).toThrow(/refused unsafe URL/);
+ });
+ });
});
-test('assigns the same URL again once the dedupe window has elapsed', () => {
- navigateTo('/dashboard/new', { assign: true });
- jest.advanceTimersByTime(1000);
- navigateTo('/dashboard/new', { assign: true });
+describe('openInNewTab — sibling-site coverage', () => {
+ let openSpy: jest.SpyInstance;
+
+ beforeEach(() => {
+ openSpy = jest.spyOn(window, 'open').mockImplementation(() => null);
+ });
+
+ afterEach(() => {
+ openSpy.mockRestore();
+ });
+
+ test.each([
+ ['empty app root', ''],
+ ['/superset app root', '/superset/'],
+ ])(
+ 'throws for /\\evil.com under %s and never calls window.open',
+ async (_label, appRoot) => {
+ await withApplicationRoot(appRoot, async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ expect(() => openInNewTab('/\\evil.com')).toThrow(/refused unsafe URL/);
+ expect(openSpy).not.toHaveBeenCalled();
+ });
+ },
+ );
+
+ test('throws for https://good@evil.com (userinfo)', async () => {
+ await withApplicationRoot('', async () => {
+ const { openInNewTab } = await import('src/utils/navigationUtils');
+ expect(() => openInNewTab('https://good@evil.example.com')).toThrow(
+ /refused unsafe URL/,
+ );
+ expect(openSpy).not.toHaveBeenCalled();
+ });
+ });
+});
+
+// AppLink renders a real React element, so its tests can't use
+// withApplicationRoot — `jest.resetModules()` corrupts @testing-library/react
+// when its dist files are re-imported across the reset. Mock applicationRoot
+// at module scope and vary it per test instead.
+//
+// Note: the mock factory is hoisted, so `mockApplicationRoot` must be
+// `mock`-prefixed to satisfy Jest's out-of-scope-variable check.
++
++// Duplicate-assign suppression (master PR #40833): a double-click that fires
++// two identical `navigateTo(..., { assign: true })` calls within 1s must reach
++// `window.location.assign` only once. The dedupe is keyed on the final,
++// app-root-prefixed sink value. These exercise the real `navigateTo` (not an
++// identity stub) so app-root prefixing and the assign barrier run end to end.
++describe('navigateTo duplicate-assign suppression', () => {
++ let originalLocation: Location;
++ let assignMock: jest.Mock;
++
++ beforeEach(() => {
++ jest.useFakeTimers();
++ originalLocation = window.location;
++ delete (window as unknown as { location?: Location }).location;
++ assignMock = jest.fn();
++ (
++ window as unknown as { location: { href: string; assign: jest.Mock } }
++ ).location = { href: '', assign: assignMock };
++ });
++
++ afterEach(() => {
++ (window as unknown as { location: Location }).location = originalLocation;
++ jest.useRealTimers();
++ });
++
++ test('ignores a repeated assign to the same URL within the dedupe window', async () => {
++ await withApplicationRoot('/superset/', async () => {
++ const { navigateTo } = await import('src/utils/navigationUtils');
++ navigateTo('/dashboard/new/', { assign: true });
++ navigateTo('/dashboard/new/', { assign: true });
++ expect(assignMock).toHaveBeenCalledTimes(1);
++ expect(assignMock).toHaveBeenCalledWith('/superset/dashboard/new/');
++ });
++ });
++
++ test('assigns different URLs in quick succession', async () => {
++ await withApplicationRoot('/superset/', async () => {
++ const { navigateTo } = await import('src/utils/navigationUtils');
++ navigateTo('/dashboard/new/', { assign: true });
++ navigateTo('/chart/add/', { assign: true });
++ expect(assignMock).toHaveBeenCalledTimes(2);
++ });
++ });
+
- expect(assignMock).toHaveBeenCalledTimes(2);
++ test('assigns the same URL again once the dedupe window has elapsed', async () => {
++ await withApplicationRoot('/superset/', async () => {
++ const { navigateTo } = await import('src/utils/navigationUtils');
++ navigateTo('/dashboard/new/', { assign: true });
++ jest.advanceTimersByTime(1000);
++ navigateTo('/dashboard/new/', { assign: true });
++ expect(assignMock).toHaveBeenCalledTimes(2);
++ });
++ });
+ });
diff --cc superset-frontend/src/utils/navigationUtils.ts
index f73507f9106,967de1fc24c..5ee26e12a68
--- a/superset-frontend/src/utils/navigationUtils.ts
+++ b/superset-frontend/src/utils/navigationUtils.ts
@@@ -16,332 -16,41 +16,360 @@@
* specific language governing permissions and limitations
* under the License.
*/
-import { sanitizeUrl } from '@braintree/sanitize-url';
-import { ensureAppRoot } from './pathUtils';
+import {
+ createElement,
+ type AnchorHTMLAttributes,
+ type ReactElement,
+} from 'react';
+import { ensureAppRoot, makeUrl, stripAppRoot } from './pathUtils';
+// Note: master PR #40546 added `import { sanitizeUrl } from
+// '@braintree/sanitize-url';` here as part of its sink-wrapping approach.
+// Dropped on merge because this file's `assertSafeNavigationUrl` /
+// inline-barrier scheme is strictly stronger: it rejects `javascript:` /
+// `data:` (scheme allowlist), backslash-laden authority spoofing,
+// and userinfo-bearing http(s)/ftp URLs — none of which
+// `sanitizeUrl` rejects. The library remains a project dep (used in
+// ListViewCard, SqlAlchemyForm, etc.) and is intentionally unused here.
+// Re-export so callers that legitimately need a raw prefixed path (native
+// fetch, navigator.sendBeacon, image src, third-party `href` props) have a
+// single sanctioned import location. The static-invariant scan disallows
+// importing from `pathUtils` directly outside this module.
+export { ensureAppRoot, makeUrl, stripAppRoot };
+
+// The guard helpers are declared before `navigateTo` / `navigateWithState`
+// so oxlint's no-use-before-define lint (which does not honour function-
+// declaration hoisting) does not fire on the wired-up imperative-nav
+// path. The focused helpers below (`openInNewTab`, `getShareableUrl`,
+// `AppLink`) also reach for `assertSafeNavigationUrl` directly.
+
+const NEW_TAB_FEATURES = 'noopener noreferrer';
+
++// Duplicate-navigation suppression for `assign`-mode navigations (master
++// PR #40833: prevents a double-click on "create dashboard" from firing two
++// identical `window.location.assign` calls and creating duplicate objects).
++// Keyed on the final, already-sanitised sink value so the dedupe decision is
++// made on exactly what would reach `window.location.assign`. This is pure
++// bookkeeping — it never touches the sink, so the inline CodeQL barriers on
++// each `assign` branch below remain intact.
+ const DUPLICATE_NAV_WINDOW_MS = 1000;
+ let lastAssignUrl: string | null = null;
+ let lastAssignAt = 0;
+
-export const navigateTo = (
++function shouldSkipDuplicateAssign(sinkValue: string): boolean {
++ const now = Date.now();
++ if (
++ lastAssignUrl === sinkValue &&
++ now - lastAssignAt < DUPLICATE_NAV_WINDOW_MS
++ ) {
++ return true;
++ }
++ lastAssignUrl = sinkValue;
++ lastAssignAt = now;
++ return false;
++}
++
+// Constant base for the URL-constructor barrier in the router-relative
+// branches below. Using a constant (rather than `window.location.origin`)
+// keeps the parse fully deterministic — test mocks that supply only
+// `window.location.href` still exercise the same code path, and CodeQL
+// recognises the literal-string origin equality as a sanitiser.
+const SAFE_PATH_PARSE_BASE = 'http://navigation-utils.invalid/';
+const SAFE_PATH_PARSE_ORIGIN = 'http://navigation-utils.invalid';
+
+// Allow-list of safe URL shapes for navigation: router-relative paths and a
+// small set of known-safe schemes. `ensureAppRoot` already neutralises
+// `javascript:` / `data:` by prefixing them as relative paths; protocol-
+// relative `//host` is intentionally excluded here because it is a cross-
+// origin navigation primitive that previously enabled open redirects.
+//
+// The leading-slash branch also rejects any URL
+// containing a backslash anywhere — browsers normalise `/\evil.com` →
+// `//evil.com` in the special-scheme authority, so backslashes in any
+// position let an attacker craft a path that looks router-relative until
+// the browser parses it. http(s)/ftp URLs with userinfo (`@` before the
+// first `/` after `//`) are rejected by the post-regex authority check
+// below, since `https://good@evil.com` resolves to the host `evil.com`
+// despite presenting as a same-origin-looking URL to the eye.
+//
+// The http(s)/ftp branches require an
+// explicit `//` after the scheme. Without it, `new URL('http:evil.com')`
+// in modern browsers parses the authority as `evil.com` — a same-origin-
+// looking absolute URL that resolves cross-origin. Mirroring the
+// protocol-relative `//host` reject from above.
+// URL strings containing C0/C1 controls
+// (`\t`/`\n`/`\r`/etc., DEL, U+0080..U+009F) or Unicode zero-width / bidi
+// formatting marks (U+200B..U+200F, U+202A..U+202E, U+2066..U+2069,
+// U+2028, U+2029, U+FEFF) are rejected outright. Browsers strip leading
+// C0 controls before parsing the leading-slash branch, so `\t//evil.com`
+// would otherwise leave the leading-slash check unable to see the
+// protocol-relative `//`. Defence-in-depth — no known active bypass
+// against the current allow-list, but the regex would otherwise depend
+// on browser-specific normalisation behaviour.
+//
+// The bidi range was
+// extended to cover the explicit-direction format characters U+202A..E
+// (LRE/RLE/PDF/LRO/RLO) and U+2066..9 (LRI/RLI/FSI/PDI). WHATWG strips
+// these before parsing the host, but the earlier comment had promised them
+// while the regex only covered U+200E/F — closing the documentation
+// drift the code review surfaced.
+const SAFE_NAVIGATION_URL_RE =
+ /^(?:\/(?!\/)|https?:\/\/|ftp:\/\/|mailto:|tel:)/i;
+const USERINFO_BEARING_SCHEME_RE = /^(?:https?|ftp):\/\//i;
+// String-literal `\u` escapes (via `new RegExp(...)`) instead of a regex
+// literal so source-file tooling (Babel parser, prettier, eslint) does
+// not have to round-trip raw bidi / zero-width / line-separator bytes.
+const FORBIDDEN_CONTROL_CHARS_RE = new RegExp(
+ '[\\x00-\\x1F\\x7F-\\x9F' +
+ '\\u200B-\\u200F' +
+ '\\u202A-\\u202E' +
+ '\\u2066-\\u2069' +
+ '\\u2028\\u2029\\uFEFF]',
+);
+
+// `encodeURI` (kept at the sinks below as CodeQL's recognised
+// `js/html-injection` sanitiser) escapes `%` itself, so an already-
+// percent-encoded path — and `parsed.pathname`/`.search`/`.hash` from the
+// URL constructor always are — would be double-encoded (`%20` → `%2520`)
+// and the navigation would land on the wrong URL. Mapping `%25XX`
+// (XX = hex) back to `%XX` after the encodeURI pass restores the
+// constructor's escape sequences. The pair is NOT a strict no-op: the
+// WHATWG serialiser emits some characters raw that encodeURI escapes
+// (`|`, `^`, `[`, `]` in paths; also `{`, `}`, backtick in queries), so
+// those end up single-encoded — semantically equivalent, since servers
+// percent-decode them back to the same resource.
+const DOUBLE_ENCODED_ESCAPE_RE = /%25([0-9A-Fa-f]{2})/g;
+
+function assertSafeNavigationUrl(url: string): string {
+ if (FORBIDDEN_CONTROL_CHARS_RE.test(url)) {
+ throw new Error(
+ 'navigationUtils refused unsafe URL: contains a forbidden ' +
+ 'control or zero-width character (would survive the allow-list ' +
+ 'as a browser-normalised navigation primitive).',
+ );
+ }
+ if (!SAFE_NAVIGATION_URL_RE.test(url) || url.includes('\\')) {
+ throw new Error(
+ 'navigationUtils refused unsafe URL: only relative paths and ' +
+ 'http(s)://, ftp://, mailto:, tel: schemes are allowed.',
+ );
+ }
+ if (USERINFO_BEARING_SCHEME_RE.test(url)) {
+ let parsed: URL;
+ try {
+ parsed = new URL(url);
+ } catch {
+ throw new Error(
+ 'navigationUtils refused unsafe URL: unparseable authority.',
+ );
+ }
+ if (parsed.username || parsed.password) {
+ throw new Error(
+ 'navigationUtils refused unsafe URL: ' +
+ 'http(s)/ftp URLs with userinfo are not allowed.',
+ );
+ }
+ }
+ return url;
+}
+
+/**
+ * Imperative full-page navigation. Internal entry point for `redirect()`
+ * and a handful of legacy callers; new code should prefer `<AppLink>` or
+ * `redirect()`. Unsafe URLs (protocol-relative, backslash-laden, userinfo-
+ * carrying http(s)) fall back to `ensureAppRoot('/')` with a `console.error`
+ * — never a silent navigation to the rejected target.
+ *
+ * Each `window.*` sink lives inside an if-block whose guard layers
+ * sanitisers so every CodeQL query family that fires on these sinks sees
+ * one it recognises:
+ *
+ * 1. `target.startsWith('/')` + `!target.startsWith('//')` +
+ * `!target.includes('\\')` — recognised by `js/client-side-
+ * unvalidated-url-redirection`; rules out protocol-relative and
+ * browser-normalised backslash-laden authority spoofing.
+ * 2. `new URL(target, SAFE_PATH_PARSE_BASE)` + literal equality on
+ * `parsed.origin` + literal equality on `parsed.protocol` —
+ * recognised by `js/xss-through-dom`. The constant base keeps the
+ * parse deterministic when test mocks supply only `window.location.
+ * { href, assign }` and not `origin`.
+ * 3. `safePath.startsWith('/')` + `!safePath.startsWith('//')` +
+ * `!safePath.includes('\\')` — extra defence-in-depth on the value
+ * actually flowing to the sink.
+ * 4. `encodeURI(safePath)` at the sink itself — `js/html-injection`'s
+ * default model only recognises specific through-function sanitisers
+ * (`encodeURI`, `encodeURIComponent`, `DOMPurify.sanitize`, …) and
+ * does NOT propagate startsWith/equality barriers from `target` or
+ * `parsed.*` through the URL-property derivation into the assigned
+ * string. Because `encodeURI` escapes `%` itself (it is NOT
+ * idempotent on percent-encoded input), each sink restores the
+ * `%XX` escape sequences afterwards via DOUBLE_ENCODED_ESCAPE_RE.
+ * Characters the WHATWG serialiser emits raw but encodeURI escapes
+ * (`|^[]{}` and backtick) stay single-encoded — semantically
+ * equivalent, not byte-identical (see DOUBLE_ENCODED_ESCAPE_RE).
+ *
+ * External-URL paths get their own block with `URL.protocol` literal-
+ * equality + userinfo guards on the URL-constructor's normalised `href`.
+ *
+ * @internal
+ */
+export function navigateTo(
url: string,
options?: { newWindow?: boolean; assign?: boolean },
-) => {
- if (options?.newWindow) {
- window.open(
- sanitizeUrl(ensureAppRoot(url)),
- '_blank',
- 'noopener noreferrer',
- );
- } else if (options?.assign) {
- const sanitized = sanitizeUrl(ensureAppRoot(url));
- const now = Date.now();
+): void {
+ const target = ensureAppRoot(url);
+ // Router-relative fast-path: triple-layer barrier so every CodeQL query
+ // family that fires on `window.location.*` / `window.history.*` sees a
+ // recognised sanitiser:
+ // 1. Outer `startsWith('/')` + `!startsWith('//')` + `!includes('\\')`
+ // on `target` — recognised by `js/client-side-unvalidated-url-
+ // redirection` and rules out protocol-relative + backslash-laden
+ // authority-spoofing.
+ // 2. URL-constructor parse + literal-equality on `parsed.origin` and
+ // `parsed.protocol` — recognised by `js/xss-through-dom`. The
+ // constant base (`http://navigation-utils.invalid/`) keeps the parse
+ // deterministic under test mocks.
+ // 3. Inline `startsWith('/')` + `!startsWith('//')` + `!includes('\\')`
+ // on `safePath` — the value actually fed to the sink. Required for
+ // `js/html-injection`, whose default model does NOT propagate
+ // sanitisers from `target` through the URL-property derivation
+ // (`parsed.pathname` etc.) into the assigned string.
+ if (
+ target.startsWith('/') &&
+ !target.startsWith('//') &&
+ !target.includes('\\')
+ ) {
+ let parsed: URL | null;
+ try {
+ parsed = new URL(target, SAFE_PATH_PARSE_BASE);
+ } catch {
+ parsed = null;
+ }
+ if (
+ parsed !== null &&
+ parsed.origin === SAFE_PATH_PARSE_ORIGIN &&
+ parsed.protocol === 'http:'
+ ) {
+ const safePath = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+ if (
+ safePath.startsWith('/') &&
+ !safePath.startsWith('//') &&
+ !safePath.includes('\\')
+ ) {
+ // `encodeURI` is CodeQL's built-in sanitiser for `js/html-injection`
+ // on `window.location.*` sinks. The previous startsWith barriers
+ // satisfy `js/url-redirection` and `js/xss-through-dom`, but
+ // `js/html-injection`'s default model only recognises specific
+ // through-function sanitisers (`encodeURI`, `encodeURIComponent`,
+ // `DOMPurify.sanitize`, …). `encodeURI` escapes `%` itself, which
+ // would double-encode the constructor-normalised path, so the
+ // follow-up replace restores the `%XX` escape sequences (see
+ // DOUBLE_ENCODED_ESCAPE_RE) — net effect: a runtime no-op for
+ // legitimate paths with the sanitiser still visible at the sink.
+ const sinkValue = encodeURI(safePath).replace(
+ DOUBLE_ENCODED_ESCAPE_RE,
+ '%$1',
+ );
+ if (options?.newWindow) {
+ window.open(sinkValue, '_blank', NEW_TAB_FEATURES);
+ } else if (options?.assign) {
- window.location.assign(sinkValue);
++ if (!shouldSkipDuplicateAssign(sinkValue)) {
++ window.location.assign(sinkValue);
++ }
+ } else {
+ window.location.href = sinkValue;
+ }
+ return;
+ }
+ }
+ }
+ // External-URL path: parse the input, verify the scheme is in our
+ // allowlist via literal equality (CodeQL recognises constant-equality
+ // barriers on `URL.protocol`), verify no userinfo, then feed the URL
+ // constructor's normalised `href` to the sink. `parsed.href` is a fresh
+ // string derived from the verified URL properties, so the data-flow
+ // chain from `url` (source) to the sink is broken by the parse +
+ // property-check pair.
+ // `SAFE_NAVIGATION_URL_RE` requires an explicit `//` after http(s)/ftp,
+ // mirroring `assertSafeNavigationUrl`. Without it, `new URL('http:evil.com')`
+ // parses the authority as `evil.com` — a cross-origin URL masquerading as a
+ // safe absolute one. The protocol-equality check below alone would accept it
+ // because `parsed.protocol` is still `http:` after normalisation.
+ let parsed: URL | null;
+ try {
+ parsed = new URL(target);
+ } catch {
+ parsed = null;
+ }
+ if (
+ parsed !== null &&
+ SAFE_NAVIGATION_URL_RE.test(target) &&
+ (parsed.protocol === 'https:' ||
+ parsed.protocol === 'http:' ||
+ parsed.protocol === 'ftp:' ||
+ parsed.protocol === 'mailto:' ||
+ parsed.protocol === 'tel:') &&
+ !parsed.username &&
+ !parsed.password
+ ) {
+ const safeExternal = parsed.href;
+ if (options?.newWindow) {
+ window.open(safeExternal, '_blank', NEW_TAB_FEATURES);
+ } else if (options?.assign) {
- window.location.assign(safeExternal);
++ if (!shouldSkipDuplicateAssign(safeExternal)) {
++ window.location.assign(safeExternal);
++ }
+ } else {
+ window.location.href = safeExternal;
+ }
+ return;
+ }
+ // eslint-disable-next-line no-console -- guarded surface, observable in dev.
+ console.error('navigationUtils.navigateTo refused unsafe URL:', url);
+ // Fallback to deployment home. Same triple-layer barrier so CodeQL sees
+ // the sanitiser at this sink too (see `navigateTo` docstring).
+ const home = ensureAppRoot('/');
+ if (home.startsWith('/') && !home.startsWith('//') && !home.includes('\\')) {
+ let homeUrl: URL | null;
+ try {
+ homeUrl = new URL(home, SAFE_PATH_PARSE_BASE);
+ } catch {
+ homeUrl = null;
+ }
if (
- lastAssignUrl === sanitized &&
- now - lastAssignAt < DUPLICATE_NAV_WINDOW_MS
+ homeUrl !== null &&
+ homeUrl.origin === SAFE_PATH_PARSE_ORIGIN &&
+ homeUrl.protocol === 'http:'
) {
- return;
+ const safeHome = `${homeUrl.pathname}${homeUrl.search}${homeUrl.hash}`;
+ if (
+ safeHome.startsWith('/') &&
+ !safeHome.startsWith('//') &&
+ !safeHome.includes('\\')
+ ) {
+ // See router-relative branch above for `encodeURI` rationale.
+ window.location.href = encodeURI(safeHome).replace(
+ DOUBLE_ENCODED_ESCAPE_RE,
+ '%$1',
+ );
+ }
}
- lastAssignUrl = sanitized;
- lastAssignAt = now;
- window.location.assign(sanitized);
- } else {
- window.location.href = sanitizeUrl(ensureAppRoot(url));
}
-};
+}
-export const navigateWithState = (
+/**
+ * Imperative history-API navigation (no page load). Unsafe URLs become a
+ * silent no-op + `console.error`; we deliberately do NOT fall back to a
+ * full-page nav here because callers (e.g. dashboard-properties save)
+ * already display their own success/failure feedback and a surprise
+ * `window.location.href = '/'` would discard unsaved state.
+ *
+ * Inline barriers mirror `navigateTo` (see its docstring) so CodeQL
+ * recognises the sanitiser at every `window.history.*` sink.
+ *
+ * @internal
+ */
+export function navigateWithState(
url: string,
state: Record<string, unknown>,
options?: { replace?: boolean },
diff --cc superset/translations/ja/LC_MESSAGES/messages.po
index 42d3353e861,7733777d44e..158d054f523
--- a/superset/translations/ja/LC_MESSAGES/messages.po
+++ b/superset/translations/ja/LC_MESSAGES/messages.po
@@@ -13830,9 -14040,9 +14040,12 @@@ msgstr "
"この JSON "
"オブジェクトは、ダッシュボード内のウィジェットの配置を記述します。ダッシュボード表示画面でドラッグ&ドロップによりサイズや位置を調整すると自動生成されます"
+msgid "This link cannot be followed because its address is unsafe."
+msgstr ""
+
+ # Machine-translated via backfill_po.py (claude-sonnet-4-6) [refs: de, sr,
+ # sr_Latn]
+ #, fuzzy
msgid ""
"This link will take you to an external website. We cannot guarantee the "
"safety of external destinations."
@@@ -14567,12 -14807,12 +14810,15 @@@ msgstr "固定を解除
msgid "Unpin from the result panel"
msgstr "結果パネルにピン留め"
+ # Machine-translated via backfill_po.py (claude-sonnet-4-6) [refs: de, sr,
+ # sr_Latn]
+ #, fuzzy
msgid "Unpin from top"
- msgstr ""
+ msgstr "上部からピン留めを解除"
+msgid "Unsafe link blocked"
+msgstr ""
+
#, python-format
msgid "Unsafe return type for function %(func)s: %(value_type)s"
msgstr "関数 %(func)s の戻り値の型「%(value_type)s」は安全ではありません"