Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate with execute_query permission
-
ExploitSubmit JSON query containing absolute URL
-
ExecutionServer-side request sent to attacker origin
-
ImpactBasic Auth credentials captured / internal service reached
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Credential Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires an authenticated Redash user holding execute_query permission on a JSON data source (per PR:L), running versions 10.0.0 up to but not including 26.9.0. The high-value outcome - credential theft - requires that the JSON data source be configured with HTTP Basic Auth (username/password), which are then forwarded to the attacker-chosen origin. SSRF to internal or private addresses additionally requires that REDASH_ENFORCE_PRIVATE_IP_BLOCK be left disabled; when that flag is enabled, private/internal access is blocked and exploitation is limited to arbitrary external origins. Limiting factors: no anonymous/unauthenticated path (valid account with query execution rights needed), no impact unless a JSON data source exists, and credential exposure is contingent on Basic Auth being configured on that source. |
| Impact | This is a genuine but moderate-severity SSRF (CWE-918), not a drop-everything emergency. The authoritative CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:L/UI:N/VC:L/VI:N/VA:N/SC:H/SI:N/SA:N, base 4.9) is internally consistent with the description: network-reachable, low complexity, but requiring a present attack condition (AT:P) and low privileges (PR:L) - specifically a user who already holds execute_query permission. The high subsequent-system confidentiality impact (SC:H) reflects the real danger: when the JSON data source is configured with HTTP Basic Auth, the server forwards those credentials to an attacker-chosen origin, so the primary loss is credential disclosure to a downstream system rather than compromise of Redash itself (VC:L). No EPSS score, KEV listing, or public exploit was provided in the input, so there is no public exploit identified at time of analysis and no evidence of active exploitation - this is a coordinated GitHub-advisory disclosure (GHSA-m723-r867-wfgw) with a vendor patch, which fits a low-urgency, patch-on-schedule posture. One important mitigating signal: access to internal/private addresses remains constrained when REDASH_ENFORCE_PRIVATE_IP_BLOCK is enabled, meaning classic cloud-metadata/internal-network SSRF is only reachable in deployments that have NOT enabled that protection. Net: real priority for internet-facing Redash instances with Basic-Auth data sources, but the authentication requirement and the optional IP-block mitigation keep real-world risk in the medium band. |
| Exploit ScenarioDerived | An authenticated analyst with execute_query permission creates or runs a JSON data source query whose URL is an absolute address pointing at an attacker-controlled server (e.g. https://attacker.example/capture). Because the vulnerable code used urljoin, the absolute URL replaces the configured base_url entirely, so the Redash server issues the request server-side; if the data source has HTTP Basic Auth configured, the username and password are transmitted to the attacker's origin. Where REDASH_ENFORCE_PRIVATE_IP_BLOCK is disabled, the same technique can be aimed at internal services. No public exploit is identified, but the fix commit ships unit tests demonstrating the bypass. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Server-side request forgery in Redash 10.0.0 through 26.9.0 allows an authenticated user holding execute_query permission on a JSON data source to redirect the query runner's HTTP request to an arbitrary external origin. The flaw stems from the use of urljoin in redash/query_runner/json_ds.py, which lets an absolute query URL replace the configured base_url instead of remaining bound to it; when the data source is configured with HTTP Basic Auth, those stored credentials are also forwarded to the attacker-selected origin, creating a credential-exfiltration path. Private and internal address access remains constrained while REDASH_ENFORCE_PRIVATE_IP_BLOCK is enabled, which limits but does not eliminate the impact; there is no confirmation of active exploitation (CISA KEV) and no public exploit code identified at time of analysis, and the assessed risk is a genuine but moderate-severity SSRF rather than an emergency.
RemediationAI
Vendor-released patch: upgrade Redash to 26.9.0, the release that contains the origin-validation fix. If an immediate upgrade is not possible, apply the upstream commit 2be9552d7e87bc3be76016e183a9f593e33073c7 (it adds _origin() and _validate_url_within_base() to redash/query_runner/json_ds.py); note that applying a commit rather than a tagged release means the patched version is not independently confirmed and regression tests (tests/query_runner/test_json_ds.py) should be run after cherry-picking. Compensating controls, each with trade-offs: keep REDASH_ENFORCE_PRIVATE_IP_BLOCK enabled so SSRF cannot reach internal or private-range addresses - this substantially reduces impact but does not stop requests to arbitrary external origins or the forwarding of Basic Auth credentials; remove or avoid configuring HTTP Basic Auth on JSON data sources, which eliminates the credential-theft outcome but breaks data sources that require authentication; restrict the execute_query permission on JSON data sources to fully trusted users, acknowledging this narrows but does not fix the vulnerable code path; and apply outbound egress filtering or an HTTP proxy allowlist so the Redash host can only reach the intended API origins, which contains blast radius but adds operational overhead and can break legitimate data sources. Because the fix only enforces same-origin and returns early when base_url is unset, deployments using JSON data sources without a base_url gain no protection from the patch and must rely on permissions and egress controls. Monitor the GHSA advisory and v26.9.0 release notes for any follow-up guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerable component is the JSON data source query runner (redash/query_runner/json_ds.py) in Redash, a data visualization and dashboarding platform. The runner builds outbound HTTP requests by combining an administrator-configured base_url with a query-supplied URL using urllib.parse.urljoin. Per RFC 3986 resolution rules, an absolute query URL (for example https://attacker.example/capture) discards the scheme, host, and path of the base URL entirely, so the resulting request leaves the trusted origin. The request is issued server-side and, when the data source has a username/password pair configured for HTTP Basic Auth, those credentials are attached to the outbound request and therefore delivered to whatever origin the user names. Internally generated URLs also passed through _get_all_results(), the shared aggregation helper that merges paginated results, which is why the fix is applied there. The root cause class is CWE-918 (Server-Side Request Forgery), specifically unsafe URL joining without origin validation. The upstream fix (commit 2be9552d7e87bc3be76016e183a9f593e33073c7) adds urlparse-based origin extraction and a _validate_url_within_base() check that compares (scheme, hostname, effective port) tuples between the resolved URL and the base URL, raising QueryParseError when they differ; the accompanying tests assert rejection of both a different-host absolute URL and the same hostname on a different port (trusted.example vs trusted.example:8443), showing that port-level separation is also enforced. Note the guard is skipped entirely when base_url is unset, and it constrains only the origin - internal-address reachability still depends on the separate REDASH_ENFORCE_PRIVATE_IP_BLOCK configuration.
Know when Redash gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:L/VI:N/VA:N/SC:H/SI:N/SA:N
Network-reachable but needs execute_query privilege (PR:L); the server-side request and credential forwarding cross into another system (S:C) with low confidentiality impact and no integrity/availability effect.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
1DescriptionCVE.org
Redash is a package for data visualization and sharing. From 10.0.0 until 26.9.0, the JSON data source query runner in redash/query_runner/json_ds.py used _get_all_results() to combine its configured base_url with a user-supplied query URL by using urljoin. An absolute query URL replaced the configured base URL instead of remaining under it, allowing a user with execute_query permission to direct a server-side request to an arbitrary external origin. When HTTP Basic Auth was configured for the data source, the request also forwarded those credentials to the selected origin. Private and internal address access remained constrained when REDASH_ENFORCE_PRIVATE_IP_BLOCK was enabled. This issue is fixed in version 26.9.0.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
Havoc Research discovered an authenticated Server-Side Request Forgery (SSRF) via the "JSON" data source of Redash open-
Redash is a package for data visualization and sharing. Rated medium severity (CVSS 6.5), this vulnerability is remotely
SQL injection in Redash (versions after 8.0.0 through 26.9.0) lets an authenticated user with view-only access to both t
Redash is a package for data visualization and sharing. Rated high severity (CVSS 8.8), this vulnerability is remotely e
Open redirect in Redash versions 5.0.2 through 26.3.0 allows unauthenticated attackers to craft a login URL that silentl
Redash is a package for data visualization and sharing. Rated medium severity (CVSS 6.1), this vulnerability is remotely
EUVD-2026-101516
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB