想象你走进一家银行办事,柜台前竖着一道厚厚的防弹玻璃。你不需要走进金库,柜员在玻璃后面帮你清点、入账、开单据——交易照常完成,但你始终摸不到现金,看到的也只是自己的一叠单据。AI 安全沙箱干的就是同一件事:让 AI 生成并执行代码来帮你完成任务,但这道代码却始终被困在一座“防弹玻璃房”里,碰不到你的真实文件、网络和操作系统。这座玻璃房,就是安全沙箱。 本文要带你认识:沙箱是什么、为什么 AI 执行代码离不开它、代码如何被隔离、权限和资源怎么限制、攻击者又如何尝试“越狱”、以及主流沙箱方案该怎么选。读完你会对这套“玻璃房安全体系”建立完整的直觉。

岗位关联

安全沙箱是 AI 应用安全的最后一道闸门。掌握它的原理与落地选型,你就能在“放心让 AI 跑代码”和“绝不让 AI 玩火”之间从容拿捏尺度——这是每一位 AI 应用工程师的必修课。

目录
  1. 可视化演示
  2. 沙箱基础概念
  3. 代码执行隔离
  4. 权限控制机制
  5. 资源限制策略
  6. 沙箱逃逸防护
  7. 主流沙箱方案
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

本节配有交互动效(进入视口后自动加载,约 3KB)。

沙箱基础概念

你走进银行兑换外币,柜员在防弹玻璃后帮你点钞、验钞、开单。你不需要走进金库,也看不到其他客户的账本——玻璃房既服务了你,又保护了银行:核心资产不暴露,客户之间的信息也互相隔离。这就是一座“信任边界”。

AI 应用里也有同样的“玻璃房”需求。当 AI 生成一段 Python 代码并要执行它时,这段代码可能是“好客户”——帮你清洗数据、算个结果;也可能被恶意 Prompt 注入——读取你的私钥、删除你的文件。安全沙箱就是为 AI 代码准备的一座“防弹玻璃房”,隔离出一个受限环境,让你放心地把代码放进去跑。

沙箱(Sandbox)本质是一个受限的执行环境,它拦截代码对操作系统、文件系统、网络、硬件的直接访问,只暴露最小可用接口。它的安全目标可以拆成三块:保密性(不偷数据)、完整性(不改数据)、可用性(不拖垮系统)。而信任边界就是“代码在沙箱里可以有条件地执行,但沙箱之外的资源,代码一概不能触碰”。AI 代码解释器、Agent 工具调用、插件市场,都是典型的沙箱落地场景。

银行不会只靠一道玻璃就营业,沙箱也不是单点技术。后面每一节,都是在给这座玻璃房加装不同的安保层。

安全等级  S=min⁡(S隔离,S权限,S资源)\displaystyle \text{安全等级}\;S = \min(S_{\text{隔离}}, S_{\text{权限}}, S_{\text{资源}})
木桶能装多少水,取决于最短的那块木板;沙箱的整体安全等级,也取决于隔离、权限、资源三块板中最弱的那一块。
  1. 安全等级 S整个沙箱系统的综合安全评分,代表对抗攻击的总体能力,取值 0~1。
    S∈[0,1]S \in [0, 1]
  2. 取最小值 min三个子安全评分中取最低的一个作为最终等级,因为攻击者永远挑最薄弱的环节打。
    min⁡(a,b,c)=三者的最小值\min(a, b, c) = \text{三者的最小值}
  3. 隔离强度 S隔离代码与外部环境的隔绝程度,分隔越彻底,评分越高。
    S隔离∈[0,1]S_{\text{隔离}} \in [0, 1]
  4. 权限收敛度 S权限AI 被授予权限的收敛程度,权限越贴合任务、面越小,得分越高。
    S权限∈[0,1]S_{\text{权限}} \in [0, 1]
  5. 资源上限 S资源CPU、内存、IO 配额设置的严格程度,额度越清晰,评分越高。
    S资源∈[0,1]S_{\text{资源}} \in [0, 1]

代码执行隔离

防弹玻璃不是普通窗户——它是一整块复合玻璃,没有窗缝可钻。对沙箱来说,代码执行隔离就是要让“玻璃”真正成片:从进程、调用、文件到网络,一层层把缝隙封死。

光说“代码被隔离”远远不够,关键要看代码的“行动路线”。AI 代码要产生效果,必须借助操作系统能力:读写文件、收发网络包、创建子进程。这些通道如果直接暴露,恶意代码就能顺着管道爬出去。

具体怎么封?四条路同时堵上。进程隔离:沙箱内的代码跑在独立进程中,操作系统负责进程间的内存与 CPU 隔离,配合容器技术进一步限制进程能看到的系统视图。系统调用过滤:用户态代码不能直接操作硬件,必须通过系统调用向内核申请;沙箱策略对系统调用逐一安检,只放行白名单里的操作。文件系统隔离:通过 chroot 和命名空间,给代码一个“虚拟文件系统”——它以为自己看到了整个磁盘,实际上只看到沙箱给它的那一小片目录。网络访问隔离:只允许访问特定域名和端口,或者干脆禁用外联。

钢化玻璃不是全密封的——柜台底部的凹槽仍在递送单据。沙箱也一样:它会保留最小的输入输出通道,但每个通道都经过安检,业务不在清单上,一律打回。

allow(c)={1c∈W0c∉W\displaystyle \text{allow}(c) = \begin{cases} 1 & c \in \mathcal{W} \\ 0 & c \notin \mathcal{W} \end{cases}
这就是“柜台业务清单”:系统调用 c 相当于客户递进来的业务申请单,白名单 W 是银行事先批准的合规业务,清单上有就办(1),没有就拒(0)。
  1. 系统调用 cAI 代码向操作系统内核提出的操作请求,比如“打开文件”“建立网络连接”。
    c=请求的操作c = \text{请求的操作}
  2. 白名单集合 W沙箱管理者预先批准的安全操作清单,相当于银行柜台贴出的“可办业务列表”。
    W={读取工作目录,写入临时文件,…}\mathcal{W} = \{\text{读取工作目录}, \text{写入临时文件}, \ldots\}
  3. 判定式 allow(c)若 c 属于白名单,返回 1 代表放行;否则返回 0 代表拒绝,请求被弹回沙箱内部。
    allow(c)=1  或  0\text{allow}(c) = 1 \;\text{或}\; 0

权限控制机制

你去银行办业务,柜员能帮你查余额、取现金,但他动不了你的保单,也进不了金库。柜员的权限是“按业务授权”的。沙箱里的 AI 代码也该如此——它可以拿到读取某个 CSV 的权限,但绝不该拥有删除整个服务器的权限。

隔离决定“代码能碰到什么”,权限决定“碰到之后能做什么”。即便代码发起了一个操作(比如“删除文件”),权限系统依然可以拒绝——就像你挤到柜台前递进一张取款单,柜员也有权说:“这项业务不在授权范围。”

具体机制有四件套。最小权限原则:只授予完成任务所必需的最小权限集合,多一项都是风险暴露面。能力白名单:用 Linux capabilities、seccomp 策略等技术,把“能力”框进白名单——文件读、写、执行分别单独授权。鉴权令牌:沙箱内代码访问受保护资源时,必须携带有效令牌,服务端先验令牌再响应,防止“伪造业务员”乱来。权限降级:启动时用高权限完成初始化工作,随后立即丢弃高权限标识,让代码以最小权限继续运行。

最小权限不是“不给权限”,而是“按需分配”。就像私人银行客户虽然有专属通道,柜员依然只看得到本次业务需要的部分,看不到资产全貌。

Pgrant=Ptask∩Pbase\displaystyle P_{\text{grant}} = P_{\text{task}} \cap P_{\text{base}}
最终授予的权限,等于“任务需要的最小权限”和“基础默认权限”的交集——两者重叠的部分才发放,任务没提的,一律不发生。
  1. 基础权限 P_base所有沙箱进程共用的默认权限集合,比如“可访问临时目录、可读环境变量”。
    Pbase={临时目录读写,环境变量读取}P_{\text{base}} = \{\text{临时目录读写}, \text{环境变量读取}\}
  2. 任务权限 P_task当前 AI 任务所需的最小权限集合,由沙箱管理者根据任务描述推演出来。
    Ptask={只读指定文件,计算输出}P_{\text{task}} = \{\text{只读指定文件}, \text{计算输出}\}
  3. 交集 ∩取两个集合的共同部分——既满足任务要求,又把权限收敛到最小,而不是简单叠加。
    Pgrant=Ptask∩PbaseP_{\text{grant}} = P_{\text{task}} \cap P_{\text{base}}

资源限制策略

银行柜台往往有取款限额,单笔不能超过五万;ATM 每日有出钞上限;VIP 室服务虽快,也要预约排队。这些“限制”不是故意刁难客户,而是确保银行整体资金流稳定,不因一笔巨额取款导致现金周转失灵。

AI 代码一旦失控,后果同样严重:死循环吃满 CPU、疯狂申请内存、把磁盘写满、无限发起网络请求——这不仅是“一个进程饿死”,而是“整个食堂都瘫痪”。邻居进程、宿主机服务全都遭殃。资源限制策略,就是给沙箱装上“额度”和“熔断闸”。

具体策略四板斧。CPU 配额:用 CFS 的 quota/period 机制限制代码的 CPU 时间片,防止单个进程占满多核。内存上限:通过 cgroup memory limit 设定硬上限,超过阈值直接 OOM Kill 强杀进程,宁可牺牲任务也不拖垮宿主机。IO 限流:限制磁盘读写带宽与 IOPS,防止“磁盘洪水”写坏硬盘。超时控制:代码运行超过 N 秒自动终止,避免死循环无限挂起。

这些额度就像银行的日终轧账和 ATM 清钞,让每一个请求都有边界,让“疯跑的代码”不会牵连旁边的“客户”。

CPUlimit=quotaperiod\displaystyle \text{CPU}_{\text{limit}} = \frac{\text{quota}}{\text{period}}
这很像银行的日取款限额:quota 是周期内能用的 CPU 时间(额度),period 是额度刷新的周期(一天),两者相除得到平均使用率上限。
  1. quota 配额一个调度周期内,该沙箱最多可以使用的 CPU 时间,单位是微秒。
    quota=10000  μs\text{quota} = 10000\;\mu\text{s}
  2. period 周期CPU 时间片轮转的固定周期,默认通常是 100000 微秒(100ms)。
    period=100000  μs\text{period} = 100000\;\mu\text{s}
  3. CPU_limit 限制两者相除,得到 CPU 使用率上限,例如 10000/100000 = 0.1,即最多占 10% CPU。
    CPUlimit=10000100000=10%\text{CPU}_{\text{limit}} = \frac{10000}{100000} = 10\%

沙箱逃逸防护

防弹玻璃能挡住子弹,但挡不住蓄意破坏者找到门缝。银行不会装完玻璃就收工——还要装监控、配保安、定期演习。沙箱逃逸防护就是这套安保体系。

攻击者是聪明的。他们会利用内核漏洞、寻找配置错误、抓住隔离实现中的缺陷,试图“逃出”沙箱,拿到宿主机的控制权。一旦沙箱逃逸(Sandbox Escape)成功,前面的所有隔离、权限、资源限制全部失效,防线彻底失守。

防护要环环相扣。逃逸途径要先摸清:内核漏洞利用(文件系统、网络子系统的越权访问)、不安全挂载与权限配置(错误的目录被误暴露)、未过滤的系统调用(借助危险 syscall 提权)。纵深防御要求多层防护叠加——容器之外再套一层虚拟机,即便第一层被突破,第二层仍能拦截。异常检测给沙箱内的行为建立基线,发现异常系统调用序列、资源突变、可疑写操作时,立即告警或阻断。漏洞响应则要求及时更新内核和沙箱版本,自动化补丁,攻击触发后快速回滚,把损失压到最小。

你无法保证玻璃永远不破,但你可以让每一次撞击都发出警报、每一道裂缝都被及时发现和修补——让“越狱”变成低概率且高成本的冒险。

Pescape=Pvuln×Ptrigger×(1−Pmitigate)\displaystyle P_{\text{escape}} = P_{\text{vuln}} \times P_{\text{trigger}} \times (1 - P_{\text{mitigate}})
逃逸成功的概率 = 漏洞存在 × 漏洞被触发 × 防护失效。任何一个环节被压到接近 0,整体逃逸概率就趋近于 0——这就是“三锁连环”。
  1. 漏洞存在概率 P_vuln沙箱内部署的软件(内核、运行时、依赖库)存在可利用漏洞的可能性。
    Pvuln∈[0,1]P_{\text{vuln}} \in [0, 1]
  2. 漏洞触发概率 P_trigger攻击者能实际构造输入、稳定触发这个漏洞的概率。
    Ptrigger∈[0,1]P_{\text{trigger}} \in [0, 1]
  3. 防护失效概率安全防护机制(如异常检测、seccomp 拦截)没能成功阻碍攻击的概率,即 1 减去缓解成功率。
    1−Pmitigate1 - P_{\text{mitigate}}
  4. 乘积关系三者相乘,任何一个趋于 0,最终逃逸概率都趋于 0——所以要同时压低三项。
    Pescape≈0P_{\text{escape}} \approx 0

主流沙箱方案

不同位置的银行网点,安保配置完全不同:社区支行可能只装普通玻璃和门禁,总行金库则用防炸弹玻璃加生物识别加轮班守卫。AI 沙箱方案的选择,本质也是“隔离强度”与“性能开销”的权衡。

工程师需要根据 AI 应用的风险等级,选择匹配的防护等级。从轻到重,主流方案分四档。Docker 容器:共享宿主内核,用 namespaces 和 cgroups 做隔离,启动快、易集成,但安全边界相对较薄,适合隔离“不可信但不太危险”的代码。gVisor:在用户态实现了一个虚拟内核 Sentry,拦截应用的所有系统调用并转译执行——相当于玻璃后还坐了一位二次审核员,隔离强度明显提升。Firecracker:亚马逊云为 Lambda 研发的微虚拟机,每个沙箱是一个微型 VM,内存开销极低、启动只要毫秒级,但隔离强度接近硬件虚拟化。WASM 沙箱:WebAssembly 运行时在纯用户态执行字节码,没有独立进程也能达成隔离,几乎零额外开销,但只适用于能编译到 WASM 的代码。

选型不是“越贵越安全”,而是“与资产匹配”。跑一段无副作用的数据清洗,用 Docker 容器足够了;运行第三方不可信插件,直接上 Firecracker 或 WASM 压阵。

开销率=延迟沙箱延迟原生×100%\displaystyle \text{开销率} = \frac{\text{延迟}_{\text{沙箱}}}{\text{延迟}_{\text{原生}}} \times 100\%
选型要看“代价”:同一段代码,在沙箱里跑的时间除以裸跑的时间,就是沙箱化带来的额外成本。防护越强,这个比例通常越高。
  1. 原生延迟不经过任何沙箱、直接在宿主机上运行代码的耗时。
    延迟原生=基准时间\text{延迟}_{\text{原生}} = \text{基准时间}
  2. 沙箱延迟同一个程序放进沙箱后再次执行的总耗时,包含隔离层的额外开销。
    延迟沙箱=沙箱内耗时\text{延迟}_{\text{沙箱}} = \text{沙箱内耗时}
  3. 开销率两个延迟相减再与原生延迟对比,得到的百分比代表性能打了多少折扣。
    开销率>100%  ⇒  存在额外损耗\text{开销率} > 100\% \;\Rightarrow\; \text{存在额外损耗}

AI 应用场景

AI 代码解释器(代码执行沙箱)

阶段:代码生成与执行

解决的问题:AI 生成的 Python 代码可能包含危险操作,比如读取用户隐私文件、删除系统文件、外联黑客服务器。传统人工审查每段代码效率低、易漏。通过沙箱执行,AI 代码只能读写用户显式上传的文件,无法访问系统目录或真实网络。

具体案例:ChatGPT 的数据分析功能——用户上传 CSV,AI 写 pandas 代码在沙箱中运行,沙箱只开放该 CSV 的读取权限和临时目录的写入权限,CPU 与内存按需配额,运行超时自动终止。

AI Agent 的工具调用沙箱

阶段:Agent 动作执行

解决的问题:Agent 调用 Shell 命令、浏览器操作、第三方 API 时,一旦被注入恶意指令,可能直接危害宿主机。传统做法依赖 Agent“本身不犯错”,不可靠;借助沙箱,Agent 的所有命令在隔离容器中执行,网络防火墙限制外联,运行超时强制终止。

具体案例:AutoGPT 类项目把代码执行放进 Docker 容器,容器只挂载一个工作目录,所有外连请求经代理服务器审批,告警日志自动收集。即便 Agent 被恶意 Prompt 劫持,也毁不掉容器之外的东西。

第三方 AI 插件市场

阶段:插件代码的加载与运行

解决的问题:插件市场里的代码由第三方开发者提供,可信度未知。传统审核靠签名和人工 review,无法穷尽恶意行为。WASM 沙箱让插件代码在纯用户态运行,不暴露文件系统和系统调用 API,从物理层面杜绝插件窃取宿主数据。

具体案例:Coze、Dify 等平台将插件编译为 WASM 模块,模块在 Wasmer 运行时中执行,只能通过平台声明的接口访问白名单资源。恶意插件即使存在,也没有“伸手”的通道。

Python 演示

python34 行
class Sandbox:    def __init__(self, allowed_ops, cpu_quota, mem_limit):        self.allowed_ops = set(allowed_ops)        self.cpu_quota = cpu_quota        self.mem_limit = mem_limit        self.used_cpu = 0        self.used_mem = 0     def execute(self, op, cpu_cost=1, mem_cost=1):        if op not in self.allowed_ops:            return "REJECT: op not in whitelist"        if self.used_cpu + cpu_cost > self.cpu_quota:            return "REJECT: cpu quota exceeded"        if self.used_mem + mem_cost > self.mem_limit:            return "REJECT: memory limit exceeded"        self.used_cpu += cpu_cost        self.used_mem += mem_cost        return "OK: " + op + " executed inside sandbox"  sandbox = Sandbox(allowed_ops=["read", "write", "calc"],                  cpu_quota=10, mem_limit=100) ops = [    ("read", 2, 10),    ("delete", 1, 10),    ("write", 2, 20),    ("calc", 5, 30),    ("write", 3, 50),] for op, cpu, mem in ops:    result = sandbox.execute(op, cpu, mem)    print(op, "=>", result)
目的:这个迷你 Sandbox 类模拟了沙箱的三大关卡——操作白名单、CPU 配额、内存上限。每次执行操作前都先过一遍安检,违规或超限直接拒绝。
  1. self.allowed_ops = set(allowed_ops)把白名单操作转成集合,后续成员判断更快更简洁。
  2. if op not in self.allowed_ops: return "REJECT..."第一道关卡:操作不在白名单,直接返回“业务不受理”。
  3. if self.used_cpu + cpu_cost > self.cpu_quota:第二道关卡:累计 CPU 消耗是否超配额,超了就不让继续跑。
  4. if self.used_mem + mem_cost > self.mem_limit:第三道关卡:内存同理,超限即拒绝。
  5. self.used_cpu += cpu_cost只有在所有关卡都通过后,才累加资源消耗,代表操作真正“在沙箱内被允许执行了”。

常见误区

误区“沙箱不就是一台虚拟机吗?给 AI 装个虚拟机就完成沙箱了。”

正解虚拟机只是沙箱的一种实现方式,两者不是一回事。沙箱的语义是“受限执行环境”,它可以是 Docker 容器、Seccomp 策略、纯软件解释器,也可以是一台虚拟机。虚拟机偏重“模拟一台完整机器”,沙箱偏重“限制程序能力”。用虚拟机做沙箱往往成本高、性能损耗大,未必是最优解。

为何常见:因为“虚拟机”是大家最熟悉的隔离技术,天然容易把“隔离”和“沙箱”划等号,忽略了沙箱是一类目标,而不是某个具体产品。

误区“把 AI 代码放进 Docker 容器,容器做了隔离,所以它就是安全沙箱,代码跑不出去。”

正解Docker 容器共享宿主内核,namespaces 和 cgroups 提供的主要是运维层面隔离(文件视图、资源限额),并非安全边界。恶意代码一旦利用内核漏洞,就能突破容器限制直击宿主机。容器要变成“安全沙箱”,必须叠加 seccomp 系统调用过滤、AppArmor、只读根文件系统,或者干脆换用 gVisor、Firecracker 这类安全隔离方案。

为何常见:容器的“隔离”和沙箱的“隔离”听起来是同一个词,让人误以为“看见隔离就等于安全”——实则是两个量级的目标。

误区“只要配置好沙箱,里面的代码就不可能出来,黑客再怎么攻击也没用。”

正解任何真实系统都存在漏洞面。内核复杂到一定程度,就无法从数学上证明其没有漏洞;沙箱逃逸攻击(内核漏洞、TOCTOU 竞态、错误配置)在安全圈里层出不穷。沙箱的真正价值是极大提高攻击成本、把逃逸概率压到极低,再配合纵深防御、异常检测和快速响应,而不是承诺“绝对安全”。

为何常见:安全产品宣传时爱说“完全隔离”,而我们都渴望存在一个配置好就一劳永逸的“银弹”,忽略了安全是持续的对抗游戏。

误区“为了安全,应该把沙箱内 AI 代码的权限压到极低,哪怕任务完成不了也没关系。”

正解最小权限原则的“最小”,指的是“恰好完成任务所需的最低权限”,而不是“越少越安全”。权限过少,AI 连正常任务都做不了,产品体验崩盘;权限过多,风险面随之扩大。正确做法是先梳理任务需要哪些能力,再精确收敛,功能与安全之间取平衡点。

为何常见:初学者容易把“少”等同于“好”,忽略了最小权限的本质是“匹配任务需要”,而不是一味做减法。

面试题

Q1. 安全沙箱的核心作用是什么?

单选题 · easy

  • A.提高代码运行速度
  • B.隔离不安全代码执行← 正确答案
  • C.加密AI模型的参数
  • D.优化提示词的内容

答案:B。沙箱的核心是“受限执行环境”,让不可信代码在隔离空间里跑,碰不到真实系统资源。A 是性能优化目标,C 属于模型安全,D 属于 Prompt 工程,都与沙箱无关。

Q2. 沙箱隔离通常包含哪些维度?

多选题 · mid

  • A.进程隔离和权限控制← 正确答案
  • B.资源配额和超时限制← 正确答案
  • C.模型参数加密存储
  • D.文件与网络访问隔离← 正确答案

答案:ABD。沙箱从进程、权限、资源、文件、网络等多个维度做限制,对应“玻璃房”的每一面墙。模型参数加密存储属于模型安全范畴,不属于沙箱隔离维度,因此不选。

Q3. gVisor 与 Docker 容器的核心区别是什么?

单选题 · mid

  • A.gVisor无额外性能开销
  • B.Docker容器是完整虚拟化
  • C.gVisor拦截系统调用隔离← 正确答案
  • D.Docker能防止内核漏洞

答案:C。gVisor 在用户态实现了虚拟内核 Sentry,所有系统调用都要经过它的拦截与转译,隔离强度明显更高。Docker 共享宿主内核,不是完整虚拟化,也无法阻止内核漏洞利用。

Q4. 最小权限原则的含义是什么?

单选题 · easy

  • A.给AI最多的系统权限
  • B.只授予任务所需权限← 正确答案
  • C.禁止所有代码运行
  • D.权限越大越便于调试

答案:B。最小权限原则强调“按需授权”,只给完成任务必需的能力,不多给一分。C 过于极端,A 和 D 恰恰是安全大忌。

Q5. CFS 配额公式中 quota 的含义是什么?

单选题 · hard

  • A.CPU时间片总周期
  • B.单周期CPU运行额← 正确答案
  • C.允许使用的内存量
  • D.进程并发数量的上限

答案:B。在 CPU_limit = quota / period 中,quota 是单个调度周期内可用的 CPU 运行额度,period 是周期长度。A 把二者颠倒了,C 是内存概念,D 与 CPU 配额公式无关。

Q6. 防护沙箱逃逸的有效策略有哪些?

多选题 · mid

  • A.采用纵深防御架构← 正确答案
  • B.及时修复底层漏洞← 正确答案
  • C.关闭所有系统警告
  • D.运行期异常行为检测← 正确答案

答案:ABD。纵深防御保证单点突破不会全线崩溃,及时补丁封堵已知漏洞,异常检测发现逃逸尝试。关闭系统警告是掩耳盗铃,反而放大风险。

Q7. Firecracker 属于哪种沙箱技术?

单选题 · hard

  • A.容器级进程隔离方案
  • B.微虚拟机安全隔离方案← 正确答案
  • C.WebAssembly纯软隔离
  • D.传统重量级虚拟机方案

答案:B。Firecracker 是亚马逊推出的微虚拟机,每个沙箱是一个微型 VM,兼顾强隔离与低开销。A 更像是 Docker,C 是 WASM,D 的传统虚拟机太重,不符合 Firecracker 的设计。

Q8. 沙箱逃逸是否能够完全阻止?

单选题 · easy

  • A.能,配置好就行
  • B.不能,只能降低概率← 正确答案
  • C.能,用最强隔离
  • D.不能,但无需防护

答案:B。复杂系统不存在绝对安全,沙箱的目标是压低逃逸概率、提高攻击成本。C 否认了漏洞存在的可能,D 则直接放弃防护,都不可取。

Q9. 系统调用白名单能带来什么效果?

单选题 · easy

  • A.只放行预先批准的调用← 正确答案
  • B.放行一切底层系统调用
  • C.让沙箱执行速度更快
  • D.直接加密所有文件数据

答案:A。白名单机制如同柜台业务清单:只有预先批准的操作才放行,清单外全部拒绝。B 是黑名单思路,C 与性能优化无关,D 是加密功能,不是白名单的职责。

Q10. AI 应用沙箱要限制文件访问,可以怎么做?

多选题 · extreme

  • A.提供虚拟只读文件系统← 正确答案
  • B.让AI自己选择访问权限
  • C.仅暴露任务所需数据路径← 正确答案
  • D.使用权限令牌校验每次读写← 正确答案

答案:ACD。虚拟只读文件系统让 AI 写入无处落地;仅暴露所需路径缩小攻击面;令牌校验确保每次访问都经过授权。让 AI 自己选权限等于没有权限控制,反而增加了被 Prompt 注入利用的风险。