CVE-2026-54629

Executive Summary

CVE-2026-54629 is an unauthenticated path traversal and arbitrary file disclosure vulnerability in Anyquery, an SQL query engine built on top of SQLite, affecting versions prior to 0.4.5. The Anyquery server exposes file-backed SQLite virtual table modules (such as csv_reader and log_reader) through its MySQL-compatible server port without authentication, authorization, or directory restrictions. A remote attacker can issue SQLite CREATE VIRTUAL TABLE statements that reference arbitrary local filesystem paths, causing the server process to read and return the contents of those files as queryable table rows — potentially disclosing system configuration, credentials, and private keys. The issue is fixed in version 0.4.5 (patch confidence 2/4 — CLAIMED by a single source, OSV; not independently confirmed).

Technical Analysis

Anyquery is an SQL query engine that extends SQLite with virtual table modules, allowing SQL to be run against non-database data sources such as CSV files and log files. The vulnerability resides in the server component, which exposes a MySQL-compatible protocol port. Prior to version 0.4.5, this server port lacked authentication, authorization, and directory restrictions for the file-backed virtual table modules csv_reader and log_reader.

The attack mechanism is rooted in the SQLite virtual table extension model. SQLite virtual tables are created via CREATE VIRTUAL TABLE ... USING <module>(<arguments>) statements. For file-backed modules such as csv_reader and log_reader, the arguments include a local filesystem path pointing to the data source. Because Anyquery's server does not restrict which paths can be supplied, an attacker who can send SQL to the MySQL-compatible port can specify an arbitrary path — including paths outside any intended data directory — and the underlying hashicorp/go-getter library, executing within the Anyquery server process, will read the referenced file and return its contents as rows in the resulting virtual table.

The CWE classification is CWE-22 (Improper Limitation of a Pathname to a Restricted Directory, i.e., Path Traversal). The core defect is the absence of path canonicalization and allow-listing: no check ensures the supplied path resides within a permitted directory, and no privilege boundary prevents unauthenticated callers from reaching the module at all. The disclosure scope is therefore bounded only by the filesystem permissions of the Anyquery server process — if that process runs with elevated privileges, sensitive system files become readable.

Two distinct access-control failures compound the path traversal: (1) no authentication on the MySQL-compatible server port, and (2) no authorization or directory restriction on the virtual table module arguments. The combination makes the vulnerability trivially exploitable by any network-reachable client capable of speaking the MySQL wire protocol.

The CVSS v3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N (score 7.5) reflects a network-reachable, low-complexity, unauthenticated attack requiring no user interaction, with a high confidentiality impact and no integrity or availability impact. The scope is unchanged: the vulnerable component and the impacted component are the same Anyquery server.

No public exploit code, PoC, or Nuclei template is known as of this writing. EPSS is 0.00966 (59.9th percentile), indicating the exploit likelihood is currently assessed as low but non-trivial relative to actively exploited CVEs. The CVE is not listed in CISA KEV.

Note: No specific source code file names, function names, HTTP endpoints, or SQL parameter names beyond those appearing verbatim in the NVD description (csv_reader, log_reader, hashicorp/go-getter) are asserted. Any implementation-level detail not present in the source description is intentionally omitted to avoid fabrication.

Exploitation Scenarios

The attack chain below is described at the vulnerability-class level and strictly adheres to the mechanism stated in the NVD description. No public PoC is available; the chain is inferred from the described flaw class (unauthenticated path traversal via SQLite virtual table modules).

1. Reconnaissance / target identification. The attacker identifies hosts running an Anyquery server by scanning for the MySQL-compatible server port (the description states the service is exposed as a "MySQL-compatible server port"). Service fingerprinting can distinguish the Anyquery MySQL-compatible endpoint from a genuine MySQL server by protocol banner and query behavior. Shodan and similar internet-scanning services can be queried for exposed instances using the dorks in the metadata section.

2. Triggering the flaw class. Once a reachable Anyquery server is identified, the attacker connects to the MySQL-compatible port. Because the port requires no authentication (per the description), the attacker can send SQL statements directly. The attacker issues a SQLite CREATE VIRTUAL TABLE statement that invokes one of the file-backed virtual table modules named in the description — csv_reader or log_reader — and supplies a local filesystem path of the attacker's choosing as the module argument. No credential is required and no directory restriction is enforced by the server.

3. Payload / execution method (vulnerability-class level). The supplied path can point outside any intended data directory — for example, toward system configuration files, credential stores, or private key material — because the server does not restrict the path. The hashicorp/go-getter library, executing inside the Anyquery server process, resolves and reads the referenced file. The file's contents are then exposed as rows of the created virtual table, which the attacker reads back through normal SQL SELECT statements over the same MySQL-compatible connection. Disclosure is limited solely by the filesystem permissions of the Anyquery server process.

4. Post-exploitation impact. The attacker extracts the contents of arbitrary readable files. Per the NVD description, this can expose "system configuration, credentials, and private keys." Disclosed credentials and private keys can enable lateral movement, privilege escalation, or persistent access to adjacent systems. The vulnerability is read-only from the attacker's perspective (CVSS integrity and availability impacts are None), so the primary post-exploitation value is intelligence gathering and credential/key theft, which may feed subsequent targeted attacks.

Constraints and caveats. The exact SQL syntax accepted by the MySQL-compatible port, the precise argument format expected by csv_reader/log_reader, and the default port number are not specified in the NVD description and are therefore not asserted here. Practitioners should validate against the fixed 0.4.5 source to confirm the module argument schema before building detection or test cases.

Impact Assessment

The CVSS v3.1 base vector is AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N with a base score of 7.5 (High). Subscore interpretation:

• Attack Vector (AV:N) — Network. Exploitation is possible remotely over the network through the exposed MySQL-compatible server port; no local access is required.
• Attack Complexity (AC:L) — Low. No specialized conditions or race windows are described; the attacker only needs to craft SQL invoking the vulnerable virtual table modules with a chosen path.
• Privileges Required (PR:N) — None. The server port requires no authentication, so an unauthenticated attacker can exploit the flaw.
• User Interaction (UI:N) — None. No victim action is needed.
• Scope (S:U) — Unchanged. The vulnerable and impacted components are the same Anyquery server process.
• Confidentiality (C:H) — High. The description states that system configuration, credentials, and private keys may be exposed; this is a severe confidentiality impact.
• Integrity (I:N) — None. The flaw discloses data; it does not modify it.
• Availability (A:N) — None. No denial-of-service impact is described.

Business impact. Any organization running an unpatched, network-reachable Anyquery server (< 0.4.5) should treat exposed instances as compromised for confidentiality purposes. Because the disclosure is bounded only by the server process's filesystem permissions, the blast radius scales with the privileges under which Anyquery runs: a process running as root or with access to mounted secrets volumes can expose the host's most sensitive material. Theft of private keys and credentials can cascade into downstream compromise of databases, cloud accounts, internal services, and machine identities, far exceeding the initial host.

Blast radius. Determined by (1) the network reachability of the MySQL-compatible port, (2) the filesystem permissions of the Anyquery server process, and (3) the sensitivity of files readable by that process. An internet-exposed instance running with broad file-read privileges represents the worst case. EPSS of 0.00966 (59.9th percentile) suggests exploitation is not currently observed at scale, but the low complexity and absence of authentication make the flaw attractive for opportunistic scanning and targeted credential harvesting.

Detection Guidance

Detection must account for two signal classes: (a) network-level observation of SQLite virtual table statements naming the file-backed modules, and (b) host-level observation of the Anyquery server process opening unexpected files.

Sigma Rule

title: Potential Anyquery Unauthenticated File Disclosure via Virtual Table Modules
id: 7c9f2a14-5462-4b7e-9d3a-1f0e54629001
status: experimental
description: Detects Anyquery server process activity consistent with exploitation of CVE-2026-54629, where CREATE VIRTUAL TABLE statements invoking file-backed modules (csv_reader, log_reader) read arbitrary local files.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-54629
author: valtersit.com
date: 2026-01-01
logsource:
  category: process_creation
  product: linux
detection:
  selection_image:
    Image|endswith:
      - '/anyquery'
      - '/anyquery-server'
  selection_cmdline:
    CommandLine|contains:
      - 'csv_reader'
      - 'log_reader'
      - 'CREATE VIRTUAL TABLE'
  condition: selection_image or selection_cmdline
fields:
  - Image
  - CommandLine
  - User
  - ParentImage
falsepositives:
  - Legitimate administrative use of Anyquery with csv_reader/log_reader against approved data directories
level: high
tags:
  - attack.t1190
  - cve.2026-54629

YARA Rule

rule CVE_2026_54629_Anyquery_VirtualTable_FileDisclosure
{
    meta:
        description = "Detects SQL payloads abusing Anyquery csv_reader/log_reader virtual table modules for arbitrary file read (CVE-2026-54629)"
        author = "valtersit.com"
        date = "2026-01-01"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-54629"
        severity = "high"

    strings:
        $vt = "CREATE VIRTUAL TABLE" nocase
        $m1 = "csv_reader" nocase
        $m2 = "log_reader" nocase
        $p1 = "/etc/passwd"
        $p2 = "/etc/shadow"
        $p3 = "/root/.ssh"

    condition:
        $vt and any of ($m1, $m2) and any of ($p1, $p2, $p3)
}

Suricata IDS Rule

alert tcp any any -> any 3306 (msg:"CVE-2026-54629 Anyquery Unauthenticated Virtual Table File Read Attempt"; flow:established,to_server; content:"CREATE VIRTUAL TABLE"; nocase; fast_pattern; content:"csv_reader"; nocase; distance:0; sid:5462901; rev:1; metadata:cve CVE-2026-54629, created_at 2026_01_01, updated_at 2026_01_01; classtype:attempted-recon; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-54629;)

alert tcp any any -> any 3306 (msg:"CVE-2026-54629 Anyquery Unauthenticated Virtual Table File Read Attempt (log_reader)"; flow:established,to_server; content:"CREATE VIRTUAL TABLE"; nocase; fast_pattern; content:"log_reader"; nocase; distance:0; sid:5462902; rev:1; metadata:cve CVE-2026-54629, created_at 2026_01_01, updated_at 2026_01_01; classtype:attempted-recon; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-54629;)

Note: The MySQL-compatible port number is not specified in the NVD description; port 3306 is used here as the conventional MySQL default and must be adjusted to the actual Anyquery server port in the environment.

Elastic Detection

sequence by process.entity_id with maxspan=5s
  [process where process.name : "anyquery*" and process.command_line : "*CREATE VIRTUAL TABLE*"]
  [file where event.action in ("open", "read") and not file.path : ("/var/lib/anyquery/*", "/opt/anyquery/data/*")]

This EQL rule correlates an Anyquery process executing a virtual-table creation with a subsequent file read outside expected data directories, which is the behavioral signature of CVE-2026-54629 exploitation.

Splunk SPL Query

index=anyquery OR index=edr sourcetype IN ("anyquery:server","mysql:audit","process_creation")
| eval qlow = lower(_raw)
| where match(qlow, "create virtual table") AND (match(qlow, "csv_reader") OR match(qlow, "log_reader"))
| eval suspicious_path = if(match(qlow, "\/etc\/|\/root\/|\.ssh|\.pem|id_rsa|passwd|shadow|\.env|credentials"), "yes", "no")
| stats count min(_time) as first_seen max(_time) as last_seen values(src_ip) as sources values(suspicious_path) as path_flag by host, user
| where path_flag="yes"
| sort - count

This query surfaces SQL containing the vulnerable virtual table modules and flags attempts that reference known-sensitive file path patterns.

Wazuh OSSEC Rule

<group name="anyquery,cve-2026-54629,">
  <rule id="546290" level="12">
    <decoded_as>json</decoded_as>
    <field name="command">\.*(CREATE VIRTUAL TABLE).*</field>
    <field name="command">\.*(csv_reader|log_reader).*</field>
    <description>CVE-2026-54629: Possible Anyquery unauthenticated virtual table file disclosure attempt</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>attack,file_disclosure,</group>
  </rule>
  <rule id="546291" level="12">
    <if_sid>554</if_sid>
    <match>csv_reader|log_reader</match>
    <description>CVE-2026-54629: Anyquery server received request referencing file-backed virtual table module</description>
    <mitre>
      <id>T1190</id>
    </mitre>
  </rule>
</group>

Adjust decoder and field names to match the deployed Anyquery server log format; the rule logic keys on the module names and the CREATE VIRTUAL TABLE statement that define the exploitation pattern.

Mitigation & Patch Guidance

Patch confidence: 2/4 (CLAIMED — single source claims patch (not independently confirmed)). The OSV source claims the issue is fixed in Anyquery version 0.4.5. Because this has not been independently corroborated by a vendor advisory or second source, treat the fix version as provisional and verify against the Anyquery release artifacts before relying on it.

1) Immediate mitigations (until patched or verified).

• Remove network exposure of the Anyquery MySQL-compatible server port. Bind the server to loopback or a trusted management network and enforce firewall rules that block untrusted access.
• Where the port must remain reachable, place it behind an authenticated, protocol-aware proxy that rejects unauthenticated sessions and filters CREATE VIRTUAL TABLE statements invoking csv_reader or log_reader.
• Run the Anyquery server process with least-privilege filesystem permissions, in a dedicated container or sandbox with a restricted mount namespace, so that even a successful path traversal cannot read sensitive host files (system configuration, credentials, private keys).
• Isolate Anyquery from sensitive mounts (secrets volumes, SSH key directories, cloud credential files).

2) Patch / upgrade steps.

• Upgrade Anyquery to version 0.4.5 or later, per the OSV-sourced fix claim. Verify the release notes and changelog confirm the removal of unauthenticated access and the addition of directory restrictions on the virtual table modules.
• Because patch confidence is only 2/4, validate the fix in a staging environment: confirm that the MySQL-compatible port now requires authentication/authorization and that csv_reader/log_reader reject paths outside an allowed directory.
• If 0.4.5 cannot be validated as a genuine fix, treat all versions as vulnerable and rely on the network-isolation mitigations above.

3) Long-term hardening.

• Enforce authentication and authorization on any management or query-facing service port; do not expose database-compatible endpoints unauthenticated.
• Implement path canonicalization and strict allow-listing for any virtual table module that accepts a filesystem path, rejecting .. traversal and absolute paths outside permitted directories.
• Apply least-privilege process execution (non-root, read-only mounts where possible, container sandboxing) as a defense-in-depth control for file-disclosure classes.
• Monitor EPSS and vendor advisories for CVE-2026-54629; escalate if the patch claim is confirmed or if exploit activity emerges.

References

• NVD — CVE-2026-54629: https://nvd.nist.gov/vuln/detail/CVE-2026-54629
• OSV — package advisory for Anyquery (source of the 0.4.5 fix claim): https://osv.dev/
• CWE-22 — Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'): https://cwe.mitre.org/data/definitions/22.html
• MITRE ATT&CK — T1190 Exploit Public-Facing Application: https://attack.mitre.org/techniques/T1190/
• Anyquery project repository / release artifacts (verify 0.4.5 fix): referenced via OSV package metadata

Exploit-in-the-wild / threat actor evidence: None observed. No CISA KEV listing, no public PoC, no exploit code, and no Nuclei template are known for CVE-2026-54629 as of this report. EPSS is 0.00966 (59.9th percentile). The exploitation scenarios above are inferred from the described vulnerability class and should be validated against the fixed 0.4.5 source before operational use.