某AI项目 0day审计过程:从 SQL 注入到匿名 RCE 的完整挖掘记录
本文仅分享某AI项目漏洞挖掘过程,不涉及poc以及任何黑盒测试内容,感兴趣的师傅可以自行复现
目标概述
NocoBase,开源无代码平台,Node.js + Sequelize + Koa 技术栈,支持 PostgreSQL / MySQL / SQLite 三种后端。GitHub 17k+ star
发现两条独立攻击链:一条 SQL 注入,一个前台 RCE。
本文不涉及poc以及任何黑盒测试内容,仅分享漏洞挖掘过程,感兴趣的师傅可以自行复现
漏洞一:SQL 注入
1.1 漏洞函数:defineMyInAppChannels
文件:packages/plugins/@nocobase/plugin-notification-in-app-message/src/server/defineMyInAppChannels.ts
这个文件用 app.resourceManager.define() 注册了一个自定义资源 myInAppChannels,只有一个 list action。整个 handler 的结构如下:
// defineMyInAppChannels.ts
export default function defineMyInAppChannels(app: Application) {
app.resourceManager.define({
name: 'myInAppChannels',
actions: {
list: {
handler: async (ctx) => {
// 1:从请求参数解构 filter,零校验
const { filter = {}, limit = 30 } = ctx.action?.params ?? {};
// 2:获取表名、字段名的物理映射
const messagesCollection = app.db.getCollection(MessagesDefinition.name);
const messagesTableName = messagesCollection.getRealTableName(true);
const channelsCollection = app.db.getCollection(ChannelsDefinition.name);
const channelsTableAliasName = app.db.sequelize
.getQueryInterface()
.quoteIdentifier(channelsCollection.name);
const messagesFieldName = {
channelName: messagesCollection.getRealFieldName(
MessagesDefinition.fieldNameMap.channelName, true
),
status: messagesCollection.getRealFieldName(
MessagesDefinition.fieldNameMap.status, true
),
userId: messagesCollection.getRealFieldName(
MessagesDefinition.fieldNameMap.userId, true
),
receiveTimestamp: messagesCollection.getRealFieldName(
MessagesDefinition.fieldNameMap.receiveTimestamp, true
),
};
const userId = ctx.state.currentUser.id;
// ③ :手写子查询 SQL(这段本身没问题,都是内部变量)
const latestMsgReceiveTimestampSQL = `(
SELECT messages.${messagesFieldName.receiveTimestamp}
FROM ${messagesTableName} AS messages
WHERE
messages.${messagesFieldName.channelName} = ${channelsTableAliasName}.${channelsFieldName.name}
AND messages.${messagesFieldName.userId} = ${userId}
ORDER BY messages.${messagesFieldName.receiveTimestamp} DESC
LIMIT 1
)`;
// 4:漏洞点
const latestMsgReceiveTSFilter = filter?.latestMsgReceiveTimestamp?.$lt
? Sequelize.literal(
`${latestMsgReceiveTimestampSQL} < ${filter.latestMsgReceiveTimestamp.$lt}`
)
: null;关键在第 ④4步。latestMsgReceiveTimestampSQL 是服务端内部构造的子查询,没问题。但 < 右边的比较值 filter.latestMsgReceiveTimestamp.$lt 直接来自 ctx.action.params——也就是 HTTP 请求参数。
这个值的数据流:
HTTP query string: ?filter[latestMsgReceiveTimestamp][$lt]=<用户输入>
↓
Koa 中间件自动解析为嵌套对象:
ctx.action.params.filter = {
latestMsgReceiveTimestamp: {
$lt: "<用户输入>" ← 字符串类型,内容完全可控
}
}
↓
const { filter } = ctx.action?.params
↓
`${latestMsgReceiveTimestampSQL} < ${filter.latestMsgReceiveTimestamp.$lt}`
↓
Sequelize.literal() ← 标记为"原始 SQL",参数化保护完全失效没有任何一层做了类型校验。$lt 的值预期是一个数字时间戳,但实际传入的是字符串,可以包含任意 SQL 片段。
1.2 literal 是怎么被执行的
光找到拼接点不够,还需要确认这个 literal 最终真的会被送进数据库执行。继续跟代码。
latestMsgReceiveTSFilter 被塞进了 where 条件:
// defineMyInAppChannels.ts
const channelsRepo = app.db.getRepository(ChannelsDefinition.name);
const channelsRes = channelsRepo.find({
limit,
attributes: { /* ... */ },
where: {
[Op.and]: [
userFilter,
latestMsgReceiveTSFilter, // ← 带注入的 Sequelize.literal()
channelIdFilter,
channelStatusFilter
].filter(Boolean),
},
sort: ['-latestMsgReceiveTimestamp'],
});channelsRepo.find() 调用的是 NocoBase 自己封装的 Repository.find():
// packages/core/database/src/repository.ts:518
async find(options: FindOptions = {}) {
const model = this.collection.model;
const transaction = await this.getTransaction(options);
const opts = {
subQuery: false,
...this.buildQueryOptions(options), // ← 构建 Sequelize 查询参数
};
rows = await model.findAll({ // ← 最终调用 Sequelize Model.findAll()
...opts,
transaction,
});
}buildQueryOptions() 在 repository.ts:942:
// packages/core/database/src/repository.ts:942
public buildQueryOptions(options: any) {
const parser = new OptionsParser(options, {
collection: this.collection,
});
const params = parser.toSequelizeParams({
parseSort: _.isBoolean(options?.parseSort) ? options.parseSort : true
});
return { where: {}, ...options, ...params };
// ^^^^^^^^^^^^^^^^^^^^^^
// options 中的 where 包含 Sequelize.literal(),直接透传
}OptionsParser 处理的是 filter、sort、fields 这些 NocoBase 自定义的查询语法。但这里的 where 条件是在 defineMyInAppChannels.ts 里已经拼好了直接传进来的,不经过 OptionsParser 的过滤逻辑——它走的是 ...options 展开,原样保留。
最终到 Sequelize 的 Model.findAll(),literal() 对象被 QueryGenerator 识别后,内容原样拼入 SQL 字符串。Sequelize 对 literal() 的处理就是完全信任,不做任何转义。
1.4 完整调用链
HTTP 请求
→ ctx.action.params.filter.latestMsgReceiveTimestamp.$lt (用户输入,字符串)
→ defineMyInAppChannels.ts:63 Sequelize.literal(`... < ${用户输入}`)
→ defineMyInAppChannels.ts:93 channelsRepo.find({ where: { [Op.and]: [literal] } })
→ repository.ts:518 Repository.find()
→ repository.ts:942 buildQueryOptions() (where 原样透传)
→ model.findAll(opts)
→ Sequelize QueryGenerator.selectQuery()
→ SQL: WHERE ... AND ((子查询) < [用户输入])
→ 数据库执行 ← 注入成功最终数据库收到的 SQL:
SELECT ...
FROM "notificationChannels" AS "notificationChannels"
WHERE (
"notificationChannels"."name" IN (...)
AND (
(SELECT messages."receiveTimestamp"
FROM "notificationInAppMessages" AS messages
WHERE messages."channelName" = "notificationChannels"."name"
AND messages."userId" = 1
ORDER BY messages."receiveTimestamp" DESC
LIMIT 1
) < 1 OR 1=1
-- ^^^^^^^^^^ 注入的 SQL 被原样执行
)
)
ORDER BY ...1.5 权限分析:谁能调用这个接口
找到注入点后,还需要确认攻击者能不能触达。看路由注册和权限控制。
myInAppChannels 通过 app.resourceManager.define() 注册,走的是 NocoBase 的统一资源路由。所有资源路由默认经过 auth 中间件和 acl 中间件。
关键问题:普通用户能不能访问?
翻 plugin-notification-in-app-message 的 plugin.ts,找 ACL 配置:
// plugin-notification-in-app-message/src/server/plugin.ts
async load() {
// ...
defineMyInAppChannels(this.app);
// ACL 配置
this.app.acl.registerSnippet({
name: `pm.${this.name}.myInAppChannels`,
actions: ['myInAppChannels:list'],
});
}registerSnippet 注册的是一个权限片段。但这里没有指定 roles——意味着它是一个通用权限片段,任何角色(包括普通 member 角色)都可以被授予这个权限。
进一步确认:NocoBase 的 ACL 体系中,member 角色默认对站内消息相关资源有读取权限(这是业务需要——每个用户都需要看到自己的站内消息)。
结论:任何认证用户(包括自注册的普通用户)都能触发这个注入点。 NocoBase 默认开放用户自注册,攻击门槛极低。
漏洞二:组合漏洞导致前台 RCE
2.1 寻找匿名可达的路由
NocoBase 的请求生命周期,所有 API 请求默认经过 auth 中间件。但有几类路由例外:
- 静态文件路由——在
gateway层直接处理,不进 Koa 中间件栈 - 特定插件注册的匿名路由——如
plugin-public-forms
先看静态文件路由。
2.2 一:路径穿越(gateway 层)
文件:packages/core/server/src/gateway/index.ts
Gateway 类的 requestHandler 方法是所有 HTTP 请求的入口。在进入 Koa 应用之前,先处理几类特殊路由:
// gateway/index.ts
async requestHandler(req: IncomingMessage, res: ServerResponse) {
const { pathname } = parse(req.url);
const { PLUGIN_STATICS_PATH, APP_PUBLIC_PATH } = process.env;
// 插件静态资源
if (pathname.startsWith(PLUGIN_STATICS_PATH)) {
// ...
}
// uploads 静态文件路由
if (pathname.startsWith(APP_PUBLIC_PATH + 'storage/uploads/')) {
req.url = req.url.substring(APP_PUBLIC_PATH.length - 1);
await compress(req, res);
return handler(req, res, {
public: resolve(process.cwd()),
directoryListing: false,
});
}
// 后续进入 Koa 应用处理 ...
}这段代码的逻辑:
- 检查
pathname是否以APP_PUBLIC_PATH + 'storage/uploads/'开头 - 是的话,截掉
APP_PUBLIC_PATH前缀,交给serve-handler处理静态文件 handler的public参数(静态根目录)设为resolve(process.cwd())
问题出在第 3 步。resolve(process.cwd()) 解析为项目根目录,不是 storage/uploads/ 目录。
这意味着 handler 会从项目根目录开始查找文件。如果请求路径包含 ../,就能穿越到 storage/uploads/ 之外的任意位置。
而第 1 步的 startsWith 检查只看前缀,不做路径归一化。/storage/uploads/..%2F..%2Fxxx 仍然以 /storage/uploads/ 开头,通过检查;但 URL 解码后的 ../../ 让 serve-handler 解析到了上级目录。
接下来的问题是:穿越出去能读到什么有价值的东西?
2.3 敏感文件枚举:JWT 密钥和数据库
NocoBase 的项目根目录结构:
nocobase/
├── packages/ # 源码
├── storage/
│ ├── uploads/ # 用户上传文件(静态文件路由的预期范围)
│ ├── apps/
│ │ └── main/
│ │ └── jwt_secret.dat # JWT 签名密钥(32字节二进制)
│ └── db/
│ └── nocobase.sqlite # SQLite 数据库(如果用 SQLite 后端)
├── .env # 环境变量(数据库密码等)
└── ...jwt_secret.dat 是 JWT 签名和验签使用的共享密钥。来看它是怎么被加载和使用的:
// packages/core/auth/src/base/jwt-service.ts
export class JwtService {
// 第12-18行:密钥加载
constructor({ secret, expiresIn }: JwtOptions) {
if (typeof secret === 'function') {
this.secretFn = secret;
} else {
this.secretFn = () => secret;
}
}
secret() {
return this.secretFn();
}
// 第40-46行:签名
sign(payload: SignPayload, options?: SignOptions) {
const opt = { expiresIn: this.expiresIn(), ...options };
return jwt.sign(payload, this.secret(), opt);
// ^^^^^^^^^^^^
// HS256 对称算法,签名和验签用同一个 secret
}
// 第48-59行:验签
decode(token: string): Promise<JwtPayload> {
return new Promise((resolve, reject) => {
jwt.verify(token, this.secret(), (err, decoded) => {
// ^^^^^^^^^^^^
// 同一个 secret
if (err) return reject(err);
resolve(decoded);
});
});
}
}HS256 是对称签名算法——知道 secret 就能伪造任意 Token。路径穿越读到 jwt_secret.dat,等于拿到了 Token 伪造能力。
如果目标用的是 SQLite 后端,还能直接穿越读到 nocobase.sqlite——整个数据库都在手里了。
2.4 二:public-forms 插件的认证绕过
有了 JWT 密钥,接下来需要找一个"接受 JWT 但不需要完整登录态"的入口。目标锁定 plugin-public-forms——这个插件的设计初衷是让匿名用户提交公开表单。
文件:packages/plugins/@nocobase/plugin-public-forms/src/server/plugin.ts
插件在 load() 中注册了两个中间件:
// plugin-public-forms/src/server/plugin.ts
async load() {
//注册在 auth 之前(关键!)
this.app.resourceManager.use(this.parseToken, { tag: 'parseToken', before: 'auth' });
//注册在 acl 之前
this.app.resourceManager.use(this.parseACL, { tag: 'parseACL', before: 'acl' });
}先看 parseToken(第118-161行):
parseToken = async (ctx, next) => {
if (!ctx.action) {
return next();
}
const { actionName, resourceName, params } = ctx.action;
// 第126-129行:特殊路由跳过(不影响攻击路径)
if (resourceName === 'publicForms' && actionName === 'getMeta' && params.password) {
return next();
}
const jwt = this.app.authManager.jwt;
const token = ctx.get('X-Form-Token'); // ← 从请求头获取 Token
if (token) {
try {
const tokenData = await jwt.decode(token); // ← 用 jwt_secret 验签
// 拿到密钥就能通过验签
ctx.PublicForm = {
collectionName: tokenData.collectionName, // ← 来自 Token payload
// ^^^^^^^^^^^^^^^^^^^^^^^^^^
// 攻击者完全可控!
formKey: tokenData.formKey,
targetCollections: tokenData.targetCollections,
};
// 第145-154行:校验 formKey 是否存在且启用
const publicForms = this.db.getRepository('publicForms');
const instance = await publicForms.findOne({
filter: {
key: tokenData.formKey, // ← formKey 必须在数据库中存在
},
});
if (!instance) {
throw new Error('The form is not found');
}
if (!instance.get('enabled')) {
throw new Error('The form is not enabled');
}
// 第155行: 直接跳过认证检查
ctx.skipAuthCheck = true;
} catch (error) {
ctx.throw(401, error.message);
}
}
await next();
};这段代码的问题:
X-Form-Token通过jwt.decode()验签——我们已经拿到了jwt_secret,可以伪造任意 Token 通过验签- Token 通过验签后,
tokenData.collectionName直接赋值给ctx.PublicForm.collectionName,没有与 formKey 对应的实际表单做关联校验 - 唯一的约束是
formKey必须在publicForms表中存在且enabled=1——但我们已经通过路径穿越拿到了数据库(SQLite 后端)或者可以通过 SQL 注入查询(PostgreSQL/MySQL 后端) - 校验通过后直接设置
ctx.skipAuthCheck = true——后续的auth中间件会检查这个标志,如果为true就跳过认证
2.5 三:ACL 绕过(collectionName 可控)
再看 parseACL(第163-185行):
parseACL = async (ctx, next) => {
if (!ctx.PublicForm) {
return next();
}
const { resourceName, actionName } = ctx.action;
const collection = this.db.getCollection(resourceName);
// 第169-171行:核心绕过逻辑
if (actionName === 'create' && ctx.PublicForm['collectionName'] === resourceName) {
ctx.permission = {
skip: true, // ← 直接跳过 ACL 检查
};
} else if (
// 第173-180行:其他放行条件
(['list', 'get'].includes(actionName) &&
ctx.PublicForm['targetCollections'].includes(resourceName)) ||
(collection?.options.template === 'file' && actionName === 'create') ||
(resourceName === 'storages' &&
['getBasicInfo', 'createPresignedUrl'].includes(actionName)) ||
(resourceName === 'vditor' && ['check'].includes(actionName)) ||
(resourceName === 'map-configuration' && actionName === 'get')
) {
ctx.permission = {
skip: true,
};
}
await next();
};第 169 行的判断逻辑:如果 actionName === 'create' 且 ctx.PublicForm.collectionName === resourceName,就跳过 ACL。
这里的设计意图是:公开表单允许匿名用户向绑定的 collection 创建记录。但问题是 ctx.PublicForm.collectionName 来源于 Token payload——攻击者完全可控。
也就是说,攻击者可以依次伪造不同的 collectionName,对任意 collection 执行 create 操作:
collectionName = "workflows"→ 匿名创建 workflowcollectionName = "flow_nodes"→ 匿名创建 workflow 节点collectionName = "users"→ 匿名创建用户collectionName = "roles"→ 匿名创建角色- ……任意 collection 均可
没有白名单,没有与 formKey 实际绑定的 collection 做交叉校验。
2.6 四:new Function() 代码执行(workflow 引擎)
能匿名创建 workflow 和 flow_nodes 之后,下一步是找一个能执行任意代码的节点类型。
NocoBase 的 workflow 引擎支持多种节点类型。翻 packages/plugins/@nocobase/plugin-workflow 的节点注册:
// plugin-workflow/src/server/Plugin.ts
async load() {
// ...
this.registerInstruction('calculation', CalculationInstruction);
this.registerInstruction('condition', ConditionInstruction);
this.registerInstruction('create', CreateInstruction);
// ...
}calculation 节点看起来最有潜力。跟进 CalculationInstruction:
// plugin-workflow/src/server/instructions/CalculationInstruction.ts
export default class CalculationInstruction extends Instruction {
async run(node, prevJob, processor) {
const { engine, expression, scope } = node.config;
// ^^^^^^ ^^^^^^^^^^
// 求值引擎 表达式内容(来自节点配置)
const evaluator = processor.options.plugin.app
.getPlugin('evaluators')
.getEvaluator(engine);
// ^^^^^^
// 根据 engine 字段选择求值引擎
const result = evaluator(expression, createScope(scope, processor));
// ^^^^^^^^^ ^^^^^^^^^^
// 执行求值 表达式由节点 config 控制
// ...
}
}engine 和 expression 都来自 node.config,而 node.config 是创建 flow_node 时由请求 body 传入的——攻击者完全可控。
继续跟 formula.js 引擎的实现:
// packages/core/evaluators/src/utils/formulajs.ts
import * as functions from '@formulajs/formulajs';
const fnNames = Object.keys(functions);
const fns = Object.values(functions);
export default evaluate.bind(function (expression: string, scope = {}) {
// 第19行: new Function() 直接执行
const fn = new Function(
...fnNames,
...Object.keys(scope),
`return ${expression}`
// ^^^^^^^^^^^^
// 表达式原样拼入 Function 体
);
const result = fn(...fns, ...Object.values(scope));
if (typeof result === 'number') {
if (Number.isNaN(result) || !Number.isFinite(result)) {
return null;
}
return round(result, 9);
}
return result;
}, {});new Function() 的语义等价于 eval()——在当前 V8 上下文中执行任意 JavaScript。没有 vm 沙箱,没有 Realm 隔离,可以直接访问:
global→ Node.js 全局对象global.process→ 进程对象global.process.mainModule.require()→ 加载任意模块
攻击者控制 expression 的值,就等于在服务端拿到了完整的 Node.js 执行权。例如:
// expression 的值:
global.process.mainModule.require("child_process").execSync("id").toString()这段代码会被拼成:
new Function('SUM', 'AVG', '...', 'return global.process.mainModule.require("child_process").execSync("id").toString()')执行后直接返回系统命令的输出。
2.7 五:Workflow 触发机制
创建了恶意 workflow + flow_node 后,还需要一个触发条件。
回看 workflow 创建时的 config:
{
"type": "collection",
"config": {
"mode": 1,
"collection": "users"
}
}type: "collection" 表示这是一个"集合事件触发器"——当指定 collection 发生 CRUD 操作时触发。mode: 1 对应 afterCreate 事件。collection: "users" 监听 users 表。
触发逻辑在 CollectionTrigger 中:
// plugin-workflow/src/server/triggers/CollectionTrigger.ts
on(workflow) {
const { collection, mode } = workflow.config;
const event = this.events[mode];
// ^^^^^^^^^^^^^^^^
// mode=1 → 'afterCreate'
const collectionModel = this.workflow.app.db.getCollection(collection);
// ^^^^^^^^^^
// "users"
collectionModel.model.addHook(event, `workflow-${workflow.id}`, async (instance) => {
// 触发 workflow 执行
this.workflow.trigger(workflow, {
data: instance.get(),
});
});
}所以:当 users 表被插入一条新记录时,workflow 被触发,进而执行 calculation 节点中的恶意 expression。
而攻击者已经通过 ACL 绕过拿到了 users:create 的匿名权限——创建一个用户就能触发执行。
2.8 完整攻击链路图
┌─────────────────────────────────────────────────────────────────────┐
│ 漏洞点1: 路径穿越 │
│ gateway/index.ts:251 │
│ pathname.startsWith(APP_PUBLIC_PATH + 'storage/uploads/') │
│ handler({ public: resolve(process.cwd()) }) │
│ ^^^^^^^^^^^^^^^^^^^^^^ │
│ 静态根目录 = 项目根目录,未做路径归一化 │
│ → 读取 storage/apps/main/jwt_secret.dat (JWT 签名密钥) │
│ → 读取 storage/db/nocobase.sqlite (SQLite 完整数据库) │
└──────────────────────────────┬──────────────────────────────────────┘
│
▼ 获得 JWT 密钥 + formKey
┌─────────────────────────────────────────────────────────────────────┐
│ 漏洞点2: 认证绕过 │
│ plugin-public-forms/plugin.ts:118-161 parseToken() │
│ jwt.decode(X-Form-Token) │
│ → 攻击者用泄露的 jwt_secret 签名 → 验签通过 │
│ ctx.PublicForm.collectionName = tokenData.collectionName │
│ ^^^^^^^^^^^^^^^^^^^^^^^^ │
│ 攻击者可控,无关联校验 │
│ ctx.skipAuthCheck = true │
│ → 跳过 auth 中间件 │
└──────────────────────────────┬──────────────────────────────────────┘
│
▼ 获得匿名请求能力
┌─────────────────────────────────────────────────────────────────────┐
│ 漏洞点3: ACL 绕过 │
│ plugin-public-forms/plugin.ts:163-185 parseACL() │
│ if (actionName === 'create' │
│ && ctx.PublicForm['collectionName'] === resourceName) │
│ ^^^^^^^^^^^^^^^ │
│ ctx.permission = { skip: true } │
│ → 攻击者逐次伪造 collectionName = workflows / flow_nodes / users │
│ → 对任意 collection 执行 create,无白名单限制 │
└──────────────────────────────┬──────────────────────────────────────┘
│
▼ 获得匿名创建任意资源能力
┌─────────────────────────────────────────────────────────────────────┐
│ 漏洞点4: 代码执行 │
│ evaluators/src/utils/formulajs.ts:19 │
│ new Function(..., `return ${expression}`) │
│ ^^^^^^^^^^ │
│ 来自 flow_node.config.expression │
│ → 无沙箱隔离,可访问 global / process / require │
│ → 攻击者控制 expression = 任意 Node.js 代码 │
└──────────────────────────────┬──────────────────────────────────────┘
│
▼ 获得代码执行能力
┌─────────────────────────────────────────────────────────────────────┐
│ 漏洞点5: 触发执行 │
│ CollectionTrigger.ts on() │
│ workflow.config = { collection: "users", mode: 1 } │
│ → model.addHook('afterCreate', ...) │
│ → 攻击者匿名 users:create → afterCreate 事件 → workflow 执行 │
│ → calculation 节点 → formulajs → new Function(恶意代码) │
│ → RCE │
└─────────────────────────────────────────────────────────────────────┘发现NocoBase中SQL注入与路径穿越漏洞,组合利用可实现前台远程代码执行。
由 AI 根据全文自动生成,仅供参考,以原文为准