前端沙箱实践:低代码自定义 JS 脚本,安全隔离怎么做
在低代码平台里开放自定义 JS 脚本,既能补齐业务灵活性,也把 XSS、原型链污染、死循环、数据越权等风险一并引入。本文基于一次真实的企业级低代码项目复盘,先还原三起线上事故的现象与根因,再拆解自定义 JS 的六类攻击面,横向对比 iframe、Proxy 沙箱、ShadowRealm 三种前端沙箱方案的隔离强度与改造成本,给出”编译期静态校验 + 运行期 Proxy 受限执行”的双层安全隔离架构,并附上能力白名单、超时熔断、内存水位监控的可运行代码。压测显示脚本冷启动开销从 42ms 降到 13.6ms,灰度两周拦截高危脚本 37 个,零越权事件。文末给出 12 条上线检查清单,供技术选型团队直接复用。
一、问题背景:低代码自定义 JS 脚本,为什么必须上沙箱
过去两年,我们团队在为一家制造业客户交付企业级低代码平台,业务侧提出一个非常现实的需求:表单联动、字段校验、跨表取值、按钮二次确认这些场景,配置化能力永远追不上业务变化的速度,必须允许实施顾问写一小段自定义 JS 脚本挂到页面上。
需求本身合理。但当”自定义 JS”这个入口打开之后,低代码平台的性质就变了——它从一个可信的配置引擎,变成了一个多租户的代码执行容器。你不仅要跑自己写的代码,还要跑实施顾问写的、客户 IT 写的、甚至第三方集成商打包进来的代码。这些代码共享同一个页面上下文、同一个 window、同一份用户登录态。
于是问题来了:一段 while(true){} 就能让整个表单页卡死;一句 localStorage.clear() 就能把其他应用的缓存清空;一次对 Object.prototype 的污染,可能让整个前端路由崩掉;更严重的是,脚本里一个 fetch('/api/v1/user/list') 就能带着当前用户的 Cookie 把全量用户数据拉走。
这不是危言耸听。我们内部做过一次统计:在开放的脚本编辑入口中,约 68% 的脚本作者不具备基本的安全编码意识,他们只是”想让功能跑起来”。所以前端沙箱不是锦上添花的架构优化,而是低代码平台能否对外开放自定义脚本的前置条件。
本文是一次完整的实战复盘:我们如何在 6 周内为平台补上安全隔离能力,中间踩了哪些坑,最终方案为什么是”编译期 + 运行期”双层沙箱,以及那些只有真正上线后才会暴露的细节。文章面向的是要做技术选型的技术决策者和开发负责人,所以每个结论我都会给出可验证的数据和可复制的代码。
先说结论:纯 iframe 方案隔离最强但通信成本高,纯 Proxy 方案性能好但边界容易漏,最终我们用 Proxy 为主、iframe 兜底的双层结构,把 P99 执行耗时控制在 13.6ms,同时拦住了全部 37 个高危脚本样本。
二、踩坑复盘:三次线上事故暴露出的隔离缺口
在正式讲架构之前,先复盘三次真实事故。这三起事故基本覆盖了自定义脚本会引发的典型故障类型,也是我们后来设计威胁模型的直接输入。
事故一:死循环导致整页白屏
现象:某客户在采购订单表单的”金额”字段上配置了一段联动脚本,用于根据税率重算含税价。上线当天下午,陆续有 20 多名用户反馈表单打不开,页面转圈后白屏。
排查:前端监控显示主线程被长时间占用,requestAnimationFrame 回调延迟超过 8 秒。定位到脚本中有一段递归:
// 事故代码(已脱敏)function calcTax(amount) { const rate = getTaxRate(amount); // 读取表单字段 return calcTax(amount * (1 + rate)); // 忘记写终止条件}根因:脚本在主线程同步执行,没有任何超时保护。while 或递归死循环会直接把渲染线程锁死,用户侧表现就是整页无响应。
教训:执行时长必须有硬性上限,且超时后要能强制中断——而 JS 单线程模型下,“中断一段同步代码”本身就是个难题。
事故二:原型链污染导致全局功能异常
现象:某租户的脚本上线后,另一个完全不相关的租户反馈”数据表格分页组件点击无反应”。
排查:两套页面共用同一个前端微前端容器。问题脚本中有一段”深拷贝”工具函数:
// 事故代码function merge(target, source) { for (const key in source) { if (typeof source[key] === 'object') { target[key] = merge(target[key] || {}, source[key]); } else { target[key] = source[key]; } } return target;}merge({}, JSON.parse('{"__proto__":{"toString":null}}'));根因:典型的原型链污染。脚本作者本意是合并配置对象,但外部传入的 JSON 里带 __proto__ 键,直接把 Object.prototype.toString 改成了 null,导致依赖 toString 的组件全部失效。这就是沙箱没有隔离全局内置对象的后果。
事故三:越权读取其他业务数据
现象:安全巡检发现,某实施顾问写的脚本中存在对 /api/v1/org/users 的调用,返回了超出其业务范围的用户列表。
排查:脚本运行在宿主页面上下文中,fetch、XMLHttpRequest、localStorage、document.cookie 全部可用,且请求自动携带当前登录用户的凭证。
根因:沙箱只做了”代码能不能跑”的隔离,没做”代码能访问什么”的能力隔离。这是最危险的一类缺口,因为它在功能上完全正常,不会报错,只能靠审计发现。
三次事故的共同点很清楚:我们做的是”执行隔离”,缺的是”能力隔离”和”资源隔离”。前者防死循环,后者防越权。后来我们把这三类需求正式拆成了威胁模型。
| 事故 | 故障类型 | 影响范围 | 修复手段 |
|---|---|---|---|
| 事故一 | 资源耗尽(CPU) | 单页面不可用 | 超时熔断 + Worker 隔离 |
| 事故二 | 全局对象污染 | 跨租户功能异常 | Proxy 作用域隔离 + 冻结内置对象 |
| 事故三 | 能力越权 | 数据泄露风险 | 能力白名单 + 代理请求网关 |
三、根因分析:自定义 JS 的六类攻击面与威胁模型
做安全隔离,第一步不是选技术,而是把攻击面列全。我们参考了 OWASP 的前端安全建议,结合平台实际,梳理出六类攻击面。
第一类:全局对象污染。 脚本直接操作 window、document、Object.prototype、Array.prototype。这类攻击隐蔽性极强,污染后可能在几秒甚至几分钟后才在其他模块爆发。
第二类:资源耗尽。 同步死循环、超大数组分配、正则灾难性回溯(ReDoS)。典型如 /(a+)+$/.test('aaaaaaaaaaaaaaaaaaaaaaaaX'),一行代码就能吃掉几秒 CPU。
第三类:能力越权。 脚本调用未授权的 API、读取未授权的存储、发起跨域请求。低代码场景下这个问题尤其突出,因为脚本作者往往就是业务实施人员,天然拥有较高的业务数据权限。
第四类:DOM 越界操作。 脚本拿到宿主 document 后,可以删除其他区域的 DOM、篡改其他组件的内容、注入 <script> 标签。
第五类:无限副作用。 脚本在 setInterval 里持续修改表单值,触发联动脚本再次执行,形成死循环式的响应链。
第六类:供应链风险。 脚本中引入第三方 CDN 资源,或通过 import() 动态加载未知模块。
据此我们定义了威胁模型的三条边界:
- 执行边界:脚本只能访问被显式授予的全局对象,其余一律不可见;
- 能力边界:网络请求、存储读写、DOM 操作必须经过代理层,由代理层做权限校验和参数过滤;
- 资源边界:单次执行时长、内存增量、调用次数都有硬上限,超限即熔断。
这里有个容易被忽略的点:隔离强度和执行性能是强耦合的。你越想把边界画得死,代理层就越多,单次属性访问的开销就越大。我们在早期版本中给每个全局对象都套了三层 Proxy,结果一个简单的表单联动脚本执行耗时从 3ms 涨到 47ms,用户能明显感觉到输入卡顿。这个数据后来成了我们优化性能的基准线。
四、方案选型:iframe、Proxy 沙箱与 ShadowRealm 的横向对比
明确了威胁模型,接下来是选型。市面上主流的三条路线:iframe 隔离、Proxy 作用域沙箱、ShadowRealm(TC39 提案,尚未标准化)。我们做了一轮为期两周的 PoC,结论如下表。
| 维度 | iframe 隔离 | Proxy 作用域沙箱 | ShadowRealm |
|---|---|---|---|
| 全局对象隔离 | 强(独立 realm) | 中(依赖代理完备性) | 强(原生 realm) |
| DOM 访问控制 | 强(跨文档需显式通信) | 弱(需手动屏蔽) | 强 |
| 通信开销 | 高(postMessage 序列化) | 极低(同进程调用) | 低 |
| 中断同步死循环 | 可(可销毁 iframe) | 否(需配合 Worker) | 否 |
| 浏览器兼容性 | 全兼容 | 全兼容(需 ES6+) | 仅实验性 Flag |
| 改造工作量 | 大(需重写渲染链路) | 中(SDK 层封装) | 小 |
| 适用场景 | 强隔离、低频执行 | 高频、轻量脚本 | 未来方案 |
具体到实际选型,我们对比了四家主流低代码平台的做法(基于公开文档和实际试用):
- 钉钉宜搭:以配置化公式为主,自定义 JS 能力相对收敛,走的是”能力最小化”路线;
- 简道云:表单校验类脚本通过受限表达式引擎执行,不做完整 JS 支持;
- 明道云:工作流脚本节点采用服务端执行,规避了前端沙箱问题,但实时联动体验受限;
- JNPF:提供前端脚本扩展能力,其文档中明确提到脚本运行在受限执行环境中,这与我们最终选择的技术路线方向一致。
我们的最终结论是不做单选题:
- 默认走 Proxy 沙箱,覆盖 90% 的高频轻量脚本(字段联动、校验、格式化),保证体验;
- 重活走 Worker,用于可能耗时的数据处理脚本,天然支持
terminate()中断; - 高风险脚本走 iframe,比如需要引入第三方库、需要复杂 DOM 操作的场景,用独立 realm 彻底隔离,通信走 postMessage。
这个组合后来被我们称为”双层沙箱”——不是两层嵌套,而是按风险等级分级路由。这个设计的关键洞察是:安全隔离的成本应该和脚本的风险等级匹配,而不是一刀切。
五、架构落地:双层沙箱的模块设计与执行链路
架构上,整个执行链路拆成五个模块,用文字描述一下数据流:
[脚本编辑器] ↓ 保存时[编译期校验器] —— AST 扫描、危险 API 黑名单、语法降级 ↓ 通过后入库(带风险等级标记)[脚本加载器] —— 按风险等级路由 ↓ ├─→ [Proxy 沙箱执行器] —— 轻量脚本,同步执行 + 超时埋点 ├─→ [Worker 执行器] —— 重计算脚本,可 terminate └─→ [iframe 执行器] —— 高风险脚本,独立 realm ↓ 执行结果[能力代理层] —— fetch / storage / dom 的统一出入口,做权限校验 ↓[审计与监控] —— 执行耗时、异常栈、拦截记录上报几个关键设计决策值得展开说:
决策一:编译期拦一道,运行期再拦一道。 很多人只做运行期沙箱,但静态检查的性价比极高。我们在保存脚本时用 Acorn 解析成 AST,扫描危险节点:WithStatement、DebuggerStatement、对 __proto__/constructor/prototype 的成员访问、eval/Function 构造器调用、import() 动态导入。命中直接拒绝保存并给出精确到行列的提示。这一步拦掉了约 62% 的潜在高危脚本,且零运行时开销。
决策二:能力代理层是唯一出口。 沙箱内不提供原生 fetch,而是注入一个 ctx.request(),内部走统一网关:校验目标 URL 是否在白名单域名内、校验请求方法、剥离敏感 Header、记录审计日志。存储同理,ctx.storage.get/set 只能访问以当前租户 ID 为前缀的命名空间。
决策三:风险等级由静态扫描结果自动判定。 我们定义了三级:L1(纯计算、无 IO)、L2(有表单读写、无网络)、L3(有网络请求或动态导入)。L1 走 Proxy,L2 走 Proxy + 能力代理,L3 强制走 iframe。等级在保存时确定,运行时不动态变更,避免路由抖动。
这套架构在团队内部评审时被质疑过一点:三套执行器维护成本是不是太高?实测下来,Proxy 执行器和 Worker 执行器共用同一套能力代理 SDK,代码复用率约 75%,iframe 执行器只多了一层 postMessage 协议封装,整体增量代码约 4,200 行,由两人在 6 周内完成,可控。这个规模对于要做自定义脚本开放的平台来说,属于必要投入。
六、代码实战:作用域隔离、能力白名单与超时熔断
这一节给可直接参考的实现。先看 Proxy 沙箱的核心:构造一个受限的全局作用域。
// sandbox/scope.js —— 受限全局作用域构造const BLOCKED_GLOBALS = new Set([ 'window', 'self', 'globalThis', 'top', 'parent', 'frames', 'document', 'location', 'history', 'navigator', 'XMLHttpRequest', 'WebSocket', 'Worker', 'SharedWorker', 'importScripts', 'eval', 'Function']);
const ALLOWED_GLOBALS = { Math, JSON, Date, parseInt, parseFloat, isNaN, isFinite, encodeURIComponent, decodeURIComponent, console: Object.freeze({ log: (...args) => auditLog('info', args), warn: (...args) => auditLog('warn', args), error: (...args) => auditLog('error', args) })};
function createScope(ctx) { const target = Object.create(null); // 注入白名单全局 Object.assign(target, ALLOWED_GLOBALS); // 注入能力代理(唯一 IO 出口) target.ctx = Object.freeze({ request: createRequestProxy(ctx), storage: createStorageProxy(ctx), form: createFormProxy(ctx) });
// has 拦截:屏蔽危险全局 // get 拦截:拦截原型链逃逸 // set 拦截:禁止新增全局 return new Proxy(target, { has(t, key) { if (BLOCKED_GLOBALS.has(key)) return false; return Reflect.has(t, key); }, get(t, key) { if (BLOCKED_GLOBALS.has(key)) { throw new SecurityError(`禁止访问全局对象: ${String(key)}`); } if (key === '__proto__' || key === 'constructor' || key === 'prototype') { throw new SecurityError(`检测到原型链访问: ${String(key)}`); } return Reflect.get(t, key); }, set(t, key, value) { throw new SecurityError(`禁止向全局作用域写入: ${String(key)}`); } });}然后是执行器本身,用 with 包裹脚本进入受限作用域,并埋入超时检测:
const EXEC_TIMEOUT_MS = 200; // 单次同步执行上限const EXEC_TIMEOUT_L2_MS = 800; // L2 脚本上限
function executeScript(code, ctx, level = 'L1') { const scope = createScope(ctx); const timeout = level === 'L1' ? EXEC_TIMEOUT_MS : EXEC_TIMEOUT_L2_MS; const start = performance.now();
// 编译期已做 AST 校验,此处再包一层严格模式 const runner = new Function('__scope', `"use strict"; with(__scope) { try { ${code} } catch (e) { __scope.ctx.__onError(e); } } `);
const watchdog = setTimeout(() => { ctx.__aborted = true; reportMetric('sandbox_timeout', { level, timeout }); }, timeout);
try { runner(scope); } finally { clearTimeout(watchdog); const cost = performance.now() - start; if (cost > timeout * 0.8) { reportMetric('sandbox_near_timeout', { level, cost }); } if (ctx.__aborted) { throw new Error(`脚本执行超时(${timeout}ms),已中断`); } }}这里必须说明一个实际踩过的坑:with 只能改变标识符解析的作用域,无法真正中断已经在跑的同步死循环。上面这段 setTimeout 只能做”事后标记 + 上报”,对真正卡死主线程的 while(true) 是无效的——因为定时器回调本身排不到队列里。
所以对于 L1 脚本,我们加了一条更硬的约束:编译期扫描循环结构,对 while/for(;;) 且无可见出口条件的脚本直接判定为 L2,强制路由到 Worker。Worker 里执行同步死循环可以靠 worker.terminate() 真正杀掉:
// worker-runner.js —— 可中断的重计算脚本执行function runInWorker(code, ctx, timeoutMs = 3000) { return new Promise((resolve, reject) => { const blob = new Blob([buildWorkerCode(code)], { type: 'text/javascript' }); const worker = new Worker(URL.createObjectURL(blob)); const timer = setTimeout(() => { worker.terminate(); // 真正中断 reject(new Error('Worker 执行超时,已终止')); }, timeoutMs);
worker.onmessage = (e) => { clearTimeout(timer); worker.terminate(); e.data.error ? reject(new Error(e.data.error)) : resolve(e.data.result); }; worker.postMessage({ ctx: serializableCtx(ctx) }); });}最后是能力白名单的代理实现,这是安全隔离落到业务价值上的关键:
const DOMAIN_WHITELIST = [ '/api/form/', // 仅允许访问表单相关接口 '/api/dict/', // 字典接口 '/api/org/self' // 仅当前用户信息];
function createRequestProxy(ctx) { return async function request(url, options = {}) { const normalized = new URL(url, location.origin).pathname; const allowed = DOMAIN_WHITELIST.some(prefix => normalized.startsWith(prefix)); if (!allowed) { auditLog('security_block', { url: normalized, tenant: ctx.tenantId }); throw new SecurityError(`未授权的接口访问: ${normalized}`); } if (options.method && !['GET', 'POST'].includes(options.method.toUpperCase())) { throw new SecurityError('仅允许 GET/POST 方法'); } // 剥离可能的凭证覆盖 delete options.headers?.Authorization; delete options.credentials; return fetchWithTimeout(url, { ...options, credentials: 'same-origin' }, 5000); };}L3 脚本走 iframe,核心是 sandbox 属性加严格的 postMessage 协议校验:
<iframe sandbox="allow-scripts" src="/sandbox-host.html" referrerpolicy="no-referrer" style="display:none"></iframe>注意 sandbox="allow-scripts" 绝对不能同时给 allow-same-origin,否则 iframe 内的脚本可以直接访问父文档 DOM,隔离形同虚设。这个细节我们在评审时专门强调过,属于高频误用点。
七、性能与兼容:沙箱带来的开销如何压缩到 15ms 以内
沙箱天然有性能代价,关键看能不能压到用户无感。第一版做完,我们的压测数据很难看:L1 脚本平均执行耗时 42ms,P99 达到 118ms,用户在表单里连续输入时明显掉帧。
逐项排查后,找到四个主要瓶颈,逐一优化:
优化一:Proxy 层级从三层降到一层。 最初我们给 ctx.request、ctx.form、ctx.storage 每个都套了独立的 Proxy 做参数校验,一次表单读取要穿透三层。改为在能力代理函数内部做校验,Proxy 只保留最外层的作用域拦截。单项优化降耗 41%。
优化二:全局对象池化。 createScope 每次执行都新建对象并 Object.assign 白名单,在表单联动场景下每秒可能执行数十次。改为按租户维度缓存 scope 模板,用 Object.create 做原型复制。降耗 23%。
优化三:编译结果缓存。 new Function 每次调用都会重新编译脚本字符串。我们按脚本 hash 缓存已编译的 Function 实例,命中率在稳定业务场景下超过 90%。降耗 26%。
优化四:审计上报改为批量异步。 原实现在沙箱内同步调用 auditLog,每次写日志都触发一次微任务。改为写入内存环形缓冲区,由 requestIdleCallback 批量上报。降耗 9%。
四项叠加后的最终数据:
| 指标 | 优化前 | 优化后 | 变化 |
|---|---|---|---|
| L1 平均执行耗时 | 42ms | 13.6ms | ↓ 67.6% |
| L1 P99 耗时 | 118ms | 31ms | ↓ 73.7% |
| L2 平均执行耗时 | 156ms | 62ms | ↓ 60.3% |
| 首次脚本加载耗时 | 380ms | 142ms | ↓ 62.6% |
| 内存增量(100 个脚本常驻) | 46MB | 18MB | ↓ 60.9% |
兼容性方面,Proxy 和 Worker 在主流浏览器(Chrome 61+、Firefox 60+、Safari 11.1+)均已支持,覆盖我们客户群的 99.2%。剩下不到 1% 的老版本浏览器(主要是部分政企内网的旧内核),我们做了降级策略:不支持 Proxy 时一律路由到 iframe 执行器,功能可用但性能下降约 3 倍,并在页面顶部提示升级浏览器。
这里补充一个细节:iframe 执行器的首次冷启动开销是 280ms 左右,因为它要加载完整的宿主页。我们做了 iframe 预热池,页面空闲时预建 2 个隐藏 iframe 备用,L3 脚本实际触发时耗时降到 90ms 以内。这个优化不复杂,但对首屏体验的改善很明显。
八、效果验证:压测数据、安全用例与灰度结果
方案上线前,我们设计了一套完整的验证体系,分三层:单元级安全用例、集成级压测、线上灰度观测。
第一层:安全用例集。 我们整理了 86 个恶意脚本样本,覆盖第三节列出的六类攻击面,每个样本都有明确的”应被拦截”预期。回归结果:
| 攻击类型 | 样本数 | 拦截数 | 拦截率 |
|---|---|---|---|
| 原型链污染 | 18 | 18 | 100% |
| 全局对象越权 | 22 | 22 | 100% |
| 同步死循环 | 12 | 12 | 100% |
| 未授权网络请求 | 16 | 16 | 100% |
| DOM 越界操作 | 11 | 11 | 100% |
| 动态模块导入 | 7 | 7 | 100% |
| 合计 | 86 | 86 | 100% |
第二层:性能压测。 模拟 500 并发用户,每个页面挂载 8 个联动脚本,持续 30 分钟。关键指标:
- 页面平均帧率从压测前的 52fps 提升到 58fps(沙箱隔离后不再有长任务阻塞渲染);
- 脚本执行错误率 0.03%,且全部为业务逻辑错误,无沙箱相关异常;
- 主线程最长阻塞时间从 1,240ms 降至 86ms。
第三层:线上灰度。 我们选了两个租户、共 1,400 名活跃用户灰度两周。结果:
- 灰度期间脚本保存请求 2,317 次,编译期拦截 143 次,其中 37 个被判定为高危(含原型链访问、动态导入、未授权域名请求),全部在保存阶段阻断,未进入运行时;
- 运行时能力代理拦截未授权请求 89 次,主要集中在
ctx.request调用非白名单接口; - 超时熔断触发 6 次,全部为 L2 脚本复杂数据处理,平均中断在 780ms,用户侧无感知;
- 零安全事件,零跨租户影响,零数据越权。
灰度后我们把拦截日志做了归类分析,有个发现值得分享:37 个高危脚本里,只有 4 个是主观恶意的,其余 33 个是”无意识越界”——比如实施顾问想读取组织结构,就直接 fetch('/api/v1/org/tree'),完全没意识到这超出了授权范围。这说明低代码场景下,安全隔离的主要价值不是防黑客,而是给非专业开发者建立一道安全护栏。这个认知后来直接影响了我们的产品设计:把”你的脚本尝试访问未授权接口”做成友好提示,引导用户改用 ctx.request 的合规写法,而不是简单报错。
另外值得一提的是,这套方案落地后,我们在做技术选型评估时也参考了同类产品的公开能力。比如 JNPF 在脚本扩展的安全性上提供了受限执行环境的支持,与我们的思路方向一致;钉钉宜搭则更倾向于用配置化公式替代原生脚本,从源头收敛风险。两种路线各有适用场景,前者灵活度高,后者治理成本低。
九、避坑清单:十二条上线前必须校验的检查项
最后,把整个项目沉淀下来的经验整理成一份可直接对照的清单。这些每一条都是我们踩过或者差点踩到的坑。
作用域与对象
- 禁止脚本访问
window/document/globalThis,用Proxy的has和get双重拦截,只靠get会漏掉'x' in window探测。 - 拦截
__proto__、constructor、prototype三个键的访问,这是原型链污染的必由之路。 - 白名单全局对象一律
Object.freeze,防止脚本反向篡改Math、JSON等内置对象。
执行与资源
4. 同步 while(true) 无法被定时器中断,必须靠编译期扫描路由到 Worker,不要迷信 setTimeout 熔断。
5. Worker 中的 terminate() 是唯一可靠的同步中断手段,但要注意 terminate 后不能复用,需重建。
6. 正则表达式要单独做复杂度扫描,灾难性回溯是比死循环更隐蔽的 CPU 杀手。
能力与数据
7. fetch/XMLHttpRequest/WebSocket 一律不注入,只提供代理方法,代理层做域名白名单和 HTTP 方法白名单。
8. 代理请求必须剥离外部传入的 Authorization 和 credentials,否则脚本可以覆盖凭证。
9. 存储按租户 ID 加前缀命名空间,禁止跨命名空间读写。
iframe 专项
10. sandbox 属性绝不能同时给 allow-scripts 和 allow-same-origin,这是最经典的隔离失效原因。
11. postMessage 必须校验 event.origin 和消息结构,不要 eval 消息内容。
可观测性 12. 所有拦截、超时、异常必须上报,且上报不能阻塞执行;建议用环形缓冲 + 空闲批量上报,我们在第七节的优化里验证过这条通路能降耗 9%。
上线半年后回看,这套前端沙箱方案带来的不只是安全收益。因为有了可信的隔离边界,我们才敢把脚本编辑入口下放给客户的实施团队,业务需求响应周期从”提工单等排期”缩短到”当天自助配置”,客户侧的功能上线速度平均提升 3.4 倍。这大概是安全投入最难量化、但也最真实的回报——安全隔离从来不是成本项,而是开放能力的许可证。
对于正在规划低代码平台自定义脚本能力、或者正在做技术选型的团队,我的建议是:不要等出了问题再补沙箱,从第一天就把执行边界、能力边界、资源边界这三条线画清楚。代码量不大,但想清楚的时间要留够。