Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain any authenticated Arc API token
-
DeliveryPOST crafted SQL to /api/v1/query
-
ExploitName unblocked DuckDB I/O function (parquet_scan/glob/read_blob)
-
ExecutionBypass table-ref extraction and RBAC check
-
ImpactRead/enumerate other tenants' data within storage root
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V14 - Data Protection Data exposure prevention
MITRE ATT&CK
2 techniques across 2 tactics: Collection, Discovery The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires an RBAC-enabled, multi-tenant Arc deployment running a version prior to 26.06.2 (the 26.06.1 partial fix is still vulnerable). The attacker must already hold a valid authenticated API token, but privilege can be minimal - even a token created with permissions:[] or scoped to a single database suffices, since RBAC never inspects table-valued function calls. Exploitation is performed by naming any of the unblocked DuckDB I/O functions (parquet_scan, glob, parquet_metadata, parquet_schema, read_blob, read_csv_auto, read_json, read_text) in a POST /api/v1/query request against any query endpoint (JSON, MsgPack, Arrow IPC, estimate). LIMITING FACTORS: single-database (non-multi-tenant) deployments are not cross-tenant affected; reads are confined to the allowlisted storage root, so out-of-root OS files, HTTP SSRF, and the sibling SQLite token database (./data/arc.db) are NOT reachable via this mechanism; and a valid token is mandatory (no unauthenticated access). |
| Impact | This is a medium-severity (CVSS 6.5) cross-database authorization bypass in Arc, scored AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N - network-reachable, low-complexity, but requiring an authenticated low-privilege token, with high confidentiality impact and no integrity or availability impact. The signals are internally consistent: PR:L matches the GHSA finding that ANY authenticated token (including a least-privilege permissions:[] RBAC token) can exploit it, and C:H/I:N/A:N matches a pure read/enumeration primitive. The CISA KEV status is not indicated in the input (treat as not listed), and no EPSS score was provided, so widespread-exploitation probability cannot be quantified from the data. The vuln.today priority decision label is 'this_month' (not act_now/emergency), which aligns with a real-but-not-critical confidentiality issue gated behind authentication. The key nuance is exposure scope: GHSA explicitly states only RBAC-enabled MULTI-TENANT deployments are cross-tenant affected - single-database deployments are not - so real-world risk is conditional on deployment mode, and the credential requirement rules out anonymous mass exploitation. Net: a genuine priority for multi-tenant Arc operators to patch this month, not a drop-everything emergency, and lower-urgency for single-tenant users. |
| Exploit ScenarioDerived | On an RBAC-enabled multi-tenant Arc deployment, an attacker holding any valid API token - even one created with permissions:[] and scoped only to their own database - sends a POST /api/v1/query request whose SQL names an unblocked DuckDB I/O function (e.g. SELECT * FROM parquet_scan('./data/arc/<victim-db>/<measurement>/**/*.parquet')). Because the query has no extracted table references, RBAC authorization is skipped and the path resolves inside the allowlisted storage root, returning another tenant's time-series rows, file listings, schema, and per-column value-range statistics. A working proof-of-concept and sample output are published in the vendor's GHSA advisory and repository (poc/poc_sandbox_alias_bypass.py, poc/OUTPUT.txt); exploitation is low-complexity once a token is held. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Authenticated cross-database data disclosure in the Arc SQL-native time-series database (versions before 26.06.2, including the partially patched 26.06.1) lets any valid API token - even one created with permissions: [] or scoped to a single database - read other tenants' Parquet telemetry data by naming DuckDB I/O table functions such as parquet_scan() in a POST /api/v1/query request. The sandbox introduced for CVE-2026-47735 allowlists the entire multi-tenant storage root, and Arc's RBAC layer never authorizes function calls, while the SQL denylist only matches the literal read_parquet( spelling, so the parquet_scan alias plus glob, parquet_metadata, parquet_schema, read_blob, read_csv_auto, read_json and read_text all slip through. A public PoC reference exists (poc/poc_sandbox_alias_bypass.py in the advisory); it is not verified as working exploit code, and no confirmed active exploitation (CISA KEV) is recorded for this CVE. Impact is confidentiality-only (CVSS 6.5, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) and is limited to RBAC-enabled multi-tenant deployments - single-database installations are not cross-tenant affected.
RemediationAI
Upgrade to Arc 26.06.2 (repository tag v26.06.2), which contains the I/O-function repair via commit 5dc8f53b70a3871b16b0cebf328f07c578af7a45 and pull request https://github.com/Basekick-Labs/arc/pull/495; upgrading to 26.06.1 alone is not sufficient because that release blocked only the literal read_parquet( and arc_partition_agg( spellings. The vendor's stated structural fixes are either per-request sandbox scoping - setting allowed_directories to the requesting token's authorized database path(s), e.g. '<base>/<authorized-db>/', so the file layer cannot cross the RBAC boundary regardless of which function is called - or replacing the function-name denylist with a strict, alias-resolved allowlist of permitted table functions and rejecting all others; the advisory explicitly warns that a denylist of literal spellings is structurally fragile, this being the second alias/family miss. Organizations that cannot upgrade immediately should treat exposure as limited to RBAC-enabled multi-tenant deployments (single-database installations are not cross-tenant affected) and should restrict issuance of query-capable tokens until a patched build is deployed; reads outside the allowlisted storage root, HTTP SSRF and the sibling SQLite token database ./data/arc.db are already unreachable through this mechanism and do not require additional compensating controls for this CVE.
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
Arc stores every database beneath a single base directory (<storage.local_path>/<database>/<measurement>/**/*.parquet via GetStoragePath in internal/storage/util.go). The 26.06.1 fix for CVE-2026-47735 relied on two layers: a DuckDB sandbox in internal/database/sandbox.go that sets allowed_directories to cfg.LocalStorageRoot with enable_external_access=false, and an Arc-side denylist regex (userSQLReadParquetPattern, \bread_parquet\s*\() in internal/api/query.go. Both layers are structurally too narrow. The sandbox scopes to the whole storage root rather than to the requesting tenant, so any in-root path is permitted regardless of ownership. The authorization layer is bypassed because extractTableReferences treats any identifier followed by an opening parenthesis as a function and skips it, and checkQueryPermissions returns allow when zero table references are extracted - so table-valued I/O functions are never checked against the token's RBAC grants. Finally, the denylist matches only one literal spelling, missing DuckDB's documented parquet_scan alias and the wider path-taking family (glob, parquet_metadata, parquet_schema, read_blob, read_csv/read_csv_auto, read_json, read_text and related). The result is CWE-200 information exposure arising from an authorization gap (the GHSA additionally classifies it as CWE-863): confidentiality of other tenants' rows, file listings, schema and per-column value-range statistics is lost while integrity and availability are unaffected. The sandbox still prevents reads outside the root (OS files, HTTP SSRF), and the sibling SQLite token database ./data/arc.db sits outside the allowlisted directory and is not exposed by this mechanism. The 26.06.2 repair replaces the single-spelling denylist with a rejection of the whole I/O function family in any query position, including comma cross-joins, subqueries, IN-lists, lateral joins and quoted-identifier spellings, across JSON, MsgPack, Arrow IPC and estimate endpoints.
Know when the next one hits your stack
- 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
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
Remote low-complexity call requiring any authenticated token (PR:L), high cross-database confidentiality read, no integrity or availability impact, and no scope change beyond the vulnerable system.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
1DescriptionCVE.org
Arc is an open, SQL-native time-series database for telemetry. Prior to the repository-verified 26.06.2 repair, the remediation of CVE-2026-47735 leaves a cross-database authorization bypass through DuckDB table-valued I/O functions. In internal/database/sandbox.go, allowed_directories uses cfg.LocalStorageRoot, configured by storage.local_path, while enable_external_access=false blocks access outside that entire multi-tenant root. GetStoragePath in internal/storage/util.go stores all databases beneath it. In internal/api/query.go, extractTableReferences skips names followed by an opening parenthesis and checkQueryPermissions allows queries with no extracted table references, including tokens with permissions: []. The userSQLReadParquetPattern denylist catches literal read_parquet( and the earlier protection also blocks arc_partition_agg(, but misses the parquet_scan alias and glob, parquet_metadata, parquet_schema, read_blob, read_csv_auto, read_json and read_text. A request to POST /api/v1/query using these unblocked functions passes ValidateSQLRequest and convertSQLToStoragePaths without tenant authorization, allowing reads and enumeration of other databases' time-series data, schema and per-column value-range statistics within the allowlisted root. The sandbox still blocks out-of-root OS files and HTTP SSRF, and the sibling SQLite token database outside the root is not exposed by this mechanism. The earlier 26.06.1 remediation does not comprehensively deny these I/O functions. Repository tag 26.06.2 contains the I/O-function repair and supplies the provisional remediation boundary; conflicting advisory affected-version statements require curator adjudication.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-114443
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB