CVE-2026-47668: Critical DbGate RCE Vulnerability
TL;DR - Critical RCE in DbGate
dbgate-servethroughPOST /runners/start. - Affects version 7.1.8 and earlier; upgrade to 7.1.9. - Public research and detection material exist; in-the-wild exploitation is not confirmed from primary sources.
Vulnerability at a Glance
| Field | Value |
|---|---|
| CVE ID | CVE-2026-47668 |
| CVSS score | 10.0 (Critical) |
| Attack vector | Network |
| Auth required | None, per CVSS vector PR:N |
| Patch available | Yes, version 7.1.9 |
CVE-2026-47668 is a critical remote code execution flaw in DbGate, specifically in the dbgate-serve deployment path and its JSON script runner. The vulnerable request path identified by the National Vulnerability Database is POST /runners/start, where attacker-controlled data can be turned into executable JavaScript.
From an operations perspective, this is the kind of issue defenders should treat as high priority even without confirmed KEV listing. The NVD assigns a 10.0 base score, and the vulnerability is described as network-exploitable with low complexity, no privileges, and no user interaction. If you expose DbGate web functionality, assume reachable systems are high risk until patched.
What Is This Vulnerability?
The root cause is unsafe dynamic code generation. According to the NVD description and the official GitHub security advisory, the functionName parameter inside JSON script assign commands is interpolated directly into generated JavaScript source code using string concatenation. That generated JavaScript is then executed in a forked Node.js child process.
In practical terms, the application takes untrusted input and places it into code, then runs that code. That is not just input validation failure in a narrow sense; it is direct code injection into a server-side execution path. Because the execution happens inside a Node.js runtime, the impact can extend well beyond the application itself and into operating system command execution, file access, and network actions, depending on how the service is deployed.
The official advisory context indicates the runtime environment may expose powerful Node.js interfaces such as process, child_process, fs, and net. The same advisory text also notes that attempted sandboxing can be bypassed through Node.js loading mechanisms such as process.mainModule.require() and module.constructor._load(). For defenders, that means this is not a theoretical parser bug or a crash-only issue. It is a likely full server compromise path.
Technical Notes
A defender-relevant summary of the vulnerable flow is:
HTTP POST /runners/start
-> JSON script runner parses attacker input
-> functionName from assign command is concatenated into JavaScript
-> generated script executes in forked Node.js child process
-> arbitrary server-side code execution may follow
The vulnerable behavior is described by the vendor and NVD as involving the functionName field of JSON script assign commands. If you are reviewing code or internal forks, search for string concatenation into generated JavaScript in the runner implementation rather than looking only for command execution APIs.
Who Is Affected?
The confirmed affected product is DbGate, specifically the dbgate-serve package or web application deployment path. The affected version range is explicitly stated as “versions 7.1.8 and prior” and ”<= 7.1.8” in the NVD and GitHub advisory material. The fixed version is explicitly stated as 7.1.9.
If you run DbGate as a desktop-only local tool and do not expose the web/server component, your exposure may differ from an internet-facing dbgate-serve deployment. However, the available primary sources tie the vulnerable code path to the JSON script runner endpoint, POST /runners/start, in the web/server product path. Organizations should inventory not just package names but actual deployment mode and exposure of the runner endpoint.
Because the public descriptions focus on dbgate-serve, defenders should prioritize:
- internet-exposed DbGate web deployments
- internally exposed administration tools reachable by many users
- containerized or npm-installed server instances
- environments where DbGate runs with broad filesystem or network access
If you cannot quickly confirm whether your installation exposes the JSON script runner, assume vulnerable behavior exists on any dbgate-serve instance at version 7.1.8 or earlier and patch accordingly. In the absence of complete deployment data, that is the safer operational assumption.
Technical Notes
Useful inventory checks may include npm/package metadata, container image tags, or release artifact review.
# Example: check installed package version where npm metadata is available
npm list dbgate-serve
# Example: inspect a container image or running container for version strings
docker exec -it <container> sh -c 'dbgate --version || cat /app/package.json | grep version'
If these commands do not apply to your environment, use your package manager, deployment manifests, or CI artifacts to identify whether dbgate-serve version 7.1.8 or earlier is present.
CVSS Score Breakdown
The published CVSS v3.1 vector is:
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
Each component matters operationally. AV:N means the vulnerability is remotely reachable over the network. AC:L means exploitation is not considered complex once the target is exposed. PR:N and UI:N together mean an attacker does not need prior authentication and does not need a victim to click or approve anything. That combination is why defenders should treat exposed instances as urgent patch candidates.
The Scope Changed (S:C) component indicates exploitation can impact resources beyond the vulnerable component’s original security boundary. In practice, that aligns with the described child-process execution model and potential access to powerful Node.js and system interfaces. The impact metrics C:H/I:H/A:H mean high confidentiality, integrity, and availability impact. That is consistent with arbitrary code execution on the server.
A 10.0 score is the maximum CVSS base score. While defenders should never rely on CVSS alone, in this case the score matches the available technical evidence: remote, low-friction, high-impact code execution with a patch already available.
Exploitation Status
Public exploit or validation material exists. The research note identifies a Nuclei template reference in the NVD-linked material and also notes a public GitHub repository named for the CVE. Those are meaningful indicators that security researchers and attackers alike can study or adapt available detection and exploit logic.
What is not established by the primary sources gathered here is confirmed in-the-wild exploitation. The CISA KEV status is reported as false, and no primary source cited in the research note states that exploitation has been observed in active attacks. Therefore, the defensible practitioner statement is: public research and detection content exist, but active exploitation in the wild is not confirmed from the primary sources reviewed.
That distinction matters. It would be wrong to claim active exploitation without evidence. It would also be a mistake to downplay risk simply because KEV does not list it. Critical unauthenticated RCE with public security material and a known endpoint is exactly the kind of issue that can move quickly from disclosure to opportunistic scanning.
Technical Notes
Monitor for probing or exploitation attempts against the runner endpoint:
POST /runners/start HTTP/1.1
Host: <dbgate-host>
Content-Type: application/json
If you have reverse proxy or WAF logging, start by isolating all requests to /runners/start, then review request bodies for unusual assign commands or suspicious functionName values.
How to Detect It
Detection should focus on two parallel goals: identifying vulnerable assets and identifying suspicious traffic to the exposed endpoint. Asset detection is straightforward: find dbgate-serve instances on version 7.1.8 or earlier. Threat detection is less direct because the public documentation does not provide a canonical exploit payload, but it does give defenders enough context to hunt effectively around the vulnerable route and parameter.
At the HTTP layer, watch for requests to POST /runners/start originating from unusual IPs, scanning infrastructure, or unauthenticated sessions. Because the flaw involves code injection through functionName in JSON script assign commands, payloads may contain JavaScript syntax fragments, Node.js module loading patterns, or references to process and child process functionality. Even if you do not know the exact exploit string, the route plus anomalous request body content is high-signal for investigation.
Internally, review Node.js process creation, child process execution telemetry, and file/network activity originating from the DbGate service account. A successful exploit may spawn unexpected subprocesses or trigger outbound connections not associated with normal database administration tasks.
Technical Notes
Example log or hunt patterns:
"POST /runners/start"
"/runners/start" AND "200"
"/runners/start" AND "functionName"
"/runners/start" AND ("process.mainModule.require" OR "module.constructor._load" OR "child_process" OR "fs" OR "net")
Example Splunk query:
index=web OR index=proxy
("POST /runners/start" OR uri_path="/runners/start")
| stats count min(_time) as firstSeen max(_time) as lastSeen by src_ip http_user_agent status uri_path host
| sort - count
Example Sigma-style idea for web or reverse proxy logs:
title: DbGate Runner Endpoint Access
logsource:
category: webserver
detection:
selection:
cs-method: POST
cs-uri-stem: /runners/start
condition: selection
level: high
Example Suricata rule concept for endpoint access visibility:
alert http any any -> $HOME_NET any (msg:"DbGate runner endpoint access"; flow:to_server,established; http.method; content:"POST"; http.uri; content:"/runners/start"; sid:4766801; rev:1;)
These detections are starting points, not proof of exploitation. If you see access to /runners/start on an internet-facing system, treat it as worthy of review even if the requests did not obviously succeed.
Mitigation and Patching
The vendor fix is clear: upgrade to DbGate version 7.1.9. The primary sources state that “Version 7.1.9 contains a patch” and list 7.1.9 as the patched version. If you are running 7.1.8 or earlier, the recommended action is to move to 7.1.9 or later as soon as change control allows.
If immediate patching is not possible, limit exposure of the JSON script runner. Because the vulnerable endpoint is POST /runners/start, defenders should restrict network access to DbGate web deployments, place the service behind VPN or internal access controls, and block direct internet exposure wherever possible. If you use a reverse proxy, consider a temporary deny rule for /runners/start if your operational workflow can tolerate disabling that feature. This is a workaround, not a substitute for upgrading.
Also review the runtime privileges of the DbGate service. While least privilege does not remove the bug, it can reduce blast radius. Restrict outbound network access, file system permissions, and shell execution rights for the service account where feasible. Those controls are compensating measures only.
Technical Notes
Example npm-style upgrade approach:
# If you manage dbgate-serve via npm
npm install dbgate-serve@7.1.9
Example package validation after upgrade:
npm list dbgate-serve
Example reverse proxy mitigation concept to block the vulnerable endpoint temporarily:
location = /runners/start {
deny all;
return 403;
}
If your deployment uses containers, update the image or manifest to a release that includes DbGate 7.1.9, then redeploy and verify the effective version in the running container. If your packaging method differs, use the vendor release artifacts corresponding to version 7.1.9. Where version data is unclear, assume pre-7.1.9 builds are unsafe until proven otherwise.
References
The primary vendor and database sources are sufficient to support patching and detection planning. The official release page confirms the fixed version, and the GitHub security advisory provides the affected range and technical context. The NVD record captures the core vulnerability description and CVSS vector.
Additional public references, including a Nuclei template and a public research repository, indicate that security validation and exploit-adjacent material is already circulating. Defenders should use those references carefully for testing in authorized environments only.
- NVD entry for CVE-2026-47668
- DbGate release 7.1.9: https://github.com/dbgate/dbgate/releases/tag/v7.1.9
- GitHub Security Advisory GHSA-8v3q-9vmx-36vc: https://github.com/dbgate/dbgate/security/advisories/GHSA-8v3q-9vmx-36vc
- Official DbGate repository: https://github.com/dbgate/dbgate
- Nuclei template reference: https://github.com/runZeroInc/nuclei-templates/blob/main/http/vulnerabilities/dbgate-unauth-rce.yaml
- Public CVE research repository surfaced in search results: https://github.com/Nxploited/CVE-2026-47668
For defenders, the bottom line is simple: if you run dbgate-serve and the version is 7.1.8 or earlier, upgrade to 7.1.9 and review access to POST /runners/start immediately.
Also, for more information on related vulnerabilities, check out our articles on CVE-2026-61447 and CVE-2026-12073.
This article may contain affiliate links. We earn a commission on qualifying purchases at no extra cost to you.