​

目标概述

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 中间件。但有几类路由例外:

  1. 静态文件路由——在 gateway 层直接处理,不进 Koa 中间件栈
  2. 特定插件注册的匿名路由——如 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 应用处理 ...
}

这段代码的逻辑:

  1. 检查 pathname 是否以 APP_PUBLIC_PATH + 'storage/uploads/' 开头
  2. 是的话,截掉 APP_PUBLIC_PATH 前缀,交给 serve-handler 处理静态文件
  3. 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();
};

这段代码的问题:

  1. X-Form-Token 通过 jwt.decode() 验签——我们已经拿到了 jwt_secret,可以伪造任意 Token 通过验签
  2. Token 通过验签后,tokenData.collectionName 直接赋值给 ctx.PublicForm.collectionName,没有与 formKey 对应的实际表单做关联校验
  3. 唯一的约束是 formKey 必须在 publicForms 表中存在且 enabled=1——但我们已经通过路径穿越拿到了数据库(SQLite 后端)或者可以通过 SQL 注入查询(PostgreSQL/MySQL 后端)
  4. 校验通过后直接设置 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" → 匿名创建 workflow
  • collectionName = "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                                                             │
└─────────────────────────────────────────────────────────────────────┘