想象你买了一套智能房子：人脸识别的门禁、会回答问题的管家机器人、存放全家照片的数据房。一天，安全顾问上门说要帮你做“防贼体检”。他没急着装锁，而是先画了一张平面图：每扇门、每扇窗、每根管道，以及一条把“家内”和“家外”分开的虚线。接着，他掏出笔记本，列出六类问题：有没有人冒充你进门？有没有人偷偷改门锁？有没有人用了房子却不认账？有没有人偷看数据房？有没有人堵住门口？有没有人拿到不该拿的钥匙？这六类问题，就是微软提出的 STRIDE 威胁建模框架。今天，我们要学着像这位顾问一样，把这套方法用在 AI 系统上，系统化找出大模型、API、数据管道里的安全隐患。

岗位关联

掌握 STRIDE 威胁建模，AI 安全架构师能一眼看穿系统最脆弱的六个入口，写出的红队报告不再是东一榔头西一棒槌。

目录
  1. 可视化演示
  2. 1. 威胁建模基础：先给房子画张平面图
  3. 2. 冒充（Spoofing）：伪造门禁卡的主人
  4. 3. 篡改（Tampering）：被换掉的监控录像
  5. 4. 抵赖（Repudiation）：用过不认账的房客
  6. 5. 信息泄露（Information Disclosure）：没拉窗帘的数据房
  7. 6. 拒绝服务（DoS）：堵住大门不让人进出
  8. 7. 权限提升（EoP）：保洁员捡到了管家钥匙
  9. 8. 清单与缓解：把防贼经验写进复查表
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

展示STRIDE六类威胁在AI系统中的映射关系与检测缓解策略

本节配有交互动效（进入视口后自动加载，约 3KB）。

STRIDE六类安全威胁全景 Spoofing伪造、Tampering篡改、Repudiation否认 Info Disclosure泄露、DoS拒绝服务、EoP权限提升 威胁 = 资产 x 漏洞 x 攻击者能力 STRIDE是系统化识别安全威胁的经典框架

1. 威胁建模基础：先给房子画张平面图

想象安全顾问走进你的智能房子，他没有立刻装锁，而是拿出白纸画图：管家机器人、数据房、门禁摄像头，以及连接它们的线路。他还画了一条虚线，把“房子外面”和“房子里面”分开。这条虚线在威胁建模里叫作信任边界，那张图叫数据流图（DFD）。画图的目的，是让所有安全隐患都能落到具体的“门”和“窗”上。

AI 系统同样可以画成一张 DFD：用户、API 网关、身份认证服务、模型服务、数据库是组件；请求、响应、训练数据是数据流。模型再黑盒，也只是图里的一个“处理节点”。把图画完，你才有基础去套用 STRIDE——微软提出的一套威胁分类方法，包括 Spoofing（冒充）、Tampering（篡改）、Repudiation（抵赖）、Information Disclosure（信息泄露）、Denial of Service（拒绝服务）、Elevation of Privilege（权限提升）。

问题这么多，先处理哪个？安全顾问通常用一个简单公式来判断严重程度：风险等于威胁发生的可能性乘以造成的影响。可能性高且影响大的威胁最先处理。

顾问画完图、排完优先级，才正式开始逐扇门检查。你也应该这样：没有 DFD 就谈威胁，等于不看平面图就说哪里会被偷。

R=P×IR = \displaystyle P \times I
风险不是简单数威胁个数，而是把“会不会发生”和“发生后多疼”乘在一起。
  1. 可能性（P）P 表示威胁在现实环境中发生的概率，可以从历史攻击事件和暴露程度估计。
    P=攻击成功次数总尝试次数P = \frac{\text{攻击成功次数}}{\text{总尝试次数}}
  2. 影响（I）I 表示威胁一旦发生对系统造成的损失强度，可用敏感数据量、停机时长等衡量。
    I=数据敏感度×影响范围I = \text{数据敏感度} \times \text{影响范围}
  3. 风险（R）R 是两者相乘，数值越高代表越需要优先缓解。
    R=P×IR = P \times I

2. 冒充（Spoofing）：伪造门禁卡的主人

一天，门铃响了，门外传来你自己的声音：“开门，我忘带钥匙了。”幸好门禁系统多问了一句：“今天早餐吃的什么？”对方答不上来。这就是 Spoofing——攻击者冒充合法身份，让系统把假货当主人。

在 AI 系统里，Spoofing 的形态很多：用 AI 合成语音骗过语音客服，用对抗样本图片骗过人脸识别，伪造 API 密钥冒充内部服务调用模型。AI 的“拟真能力”让冒充变得比以前更容易，所以认证环节必须强化。

缓解思路是增加认证因子。门禁卡是“你知道什么”，指纹是“你是什么”，动态验证码是“你拥有什么”。多因子认证让攻击者必须同时突破多道门。假设每一道门被攻破的概率是 \(p_i\)，那么整体被攻破需要所有门都被打开。

装了三道锁，小偷就不会只惦记一张门禁卡了。AI 系统的认证，也应让“冒充”的成本高到攻击者放弃。

Pbypass=∏i=1npiP_{\text{bypass}} = \displaystyle \prod_{i=1}^{n} p_i
多个因子不是相加而是相乘，概率会越来越小。
  1. 单因子概率 \(p_i\)每个认证因子都可能被攻破，值在 0 到 1 之间。
    pi=0.1p_i = 0.1
  2. 连乘符号 \(\prod\)把 n 个因子的成功概率全部乘起来。
    ∏i=1npi=p1×p2×⋯×pn\prod_{i=1}^{n} p_i = p_1 \times p_2 \times \dots \times p_n
  3. 整体冒充概率小于任一单因子因为每个因子都是小数，乘得越多越小。
    Pbypass<pmin⁡P_{\text{bypass}} < p_{\min}

3. 篡改（Tampering）：被换掉的监控录像

小偷没有撬锁，却拆下摄像头，把存储卡换成一段重复的旧录像。你看到的“一切正常”，其实是被人精心改过的。篡改的本质，是数据和程序在传输或存储中被偷换。

AI 场景里，篡改无处不在：攻击者在训练集里投放有毒样本，让模型悄悄学会偏见；通过提示注入修改大模型的行为；替换已部署的模型权重，让模型变成“卧底”。这些攻击都不需要攻入你的心腹，只需要在数据流经过的某个环节“动动手脚”。

防篡改的核心是完整性校验。最常见的工具是哈希函数：不管多长的数据，都会算出一个固定长度的摘要。只要原始数据改一个比特，摘要完全不同。n 位哈希的碰撞概率极小。

给训练数据、模型权重和 API 响应都配上“指纹”，谁再想偷换录像，一比对就露馅。

Pcollision=2−nP_{\text{collision}} = \displaystyle 2^{-n}
哈希碰撞概率随着位数的增加指数下降，就像在宇宙里找两片完全相同的雪花。
  1. 基数 2二进制哈希每一位只有 0 或 1 两种可能状态。
    22
  2. 负指数 \(-n\)位数每增加 1，碰撞概率就除以 2。
    2−1=12,2−256=122562^{-1}=\frac{1}{2},\quad 2^{-256}=\frac{1}{2^{256}}
  3. 近似为 0位数足够大时，碰撞概率低到可以忽略。
    Pcollision≈0P_{\text{collision}} \approx 0

4. 抵赖（Repudiation）：用过不认账的房客

半夜有人进了数据房，第二天却说“我没去过”。管家机器人因为没有日志，只能呆立当场。抵赖威胁，就是系统缺少可信证据，让用户或内部进程可以否认自己的操作。

在 AI 系统里，抵赖可能出现在这些地方：某人调用模型生成了有害内容，事后说不是自己发的；管理员改了模型参数导致事故，却找不到修改记录；数据被外部 API 抓走，没有调用审计。没有日志和签名，红队报告写得再精彩，也无法定责。

数字签名是防抵赖的利器。发送方用私钥对消息摘要签名，接收方用公钥验签。只要验签通过，就证明这条消息确实来自持有私钥的人，且没被改过。

给关键操作加上审计日志和数字签名，相当于给房子装了一台 24 小时不宕机的黑匣子，谁都别想赖账。

V=1{ H(m)=Dpub(σ) }V = \mathbb{1}\{\ H(m) = D_{\text{pub}}(\sigma)\ \}
\(V\) 等于 1 表示验签通过，等于 0 表示签名无效或消息被篡改。
  1. \(H(m)\) 计算消息摘要先把消息压缩成一个固定长度的指纹。
    H(m)=hash(m)H(m) = \text{hash}(m)
  2. \(D_{\text{pub}}(\sigma)\) 用公钥解密签名如果签名确实由对应私钥生成，解密结果应等于原摘要。
    σ=Epriv(H(m))\sigma = E_{\text{priv}}(H(m))
  3. 指示函数 \(\mathbb{1}\{\}\)条件成立返回 1，不成立返回 0。
    V={1H(m)=Dpub(σ)0其他V = \begin{cases} 1 & H(m) = D_{\text{pub}}(\sigma) \\ 0 & \text{其他} \end{cases}

5. 信息泄露（Information Disclosure）：没拉窗帘的数据房

你把病历和银行账单摊在桌上，路人透过窗户看得一清二楚。信息泄露威胁的核心，是敏感数据被不该看到的人或系统看了去。

AI 场景的信息泄露更具隐蔽性：攻击者可以通过成员推理攻击，判断某条记录是否在训练集里；通过模型输出反推训练数据；通过日志侧信道摸清内部结构。模型本身没问题，但它的“记忆”和“输出”都可能成为泄密口。

缓解信息泄露，要从数据全生命周期下手：训练前脱敏，传输中加密，访问时最小权限，输出时过滤敏感内容。泄露影响可以用下面公式估算。

拉好窗帘、锁好文件柜，再给每个房间配不同钥匙。AI 系统的数据也应当按这个道理层层设防。

Ileak=C×NI_{\text{leak}} = \displaystyle C \times N
敏感程度再高，如果没有暴露给很多人，损失也可控；反之亦然。
  1. 敏感等级 \(C\)身份证号、病历比公开文章敏感得多。
    C∈{1,2,3,4,5}C \in \{1, 2, 3, 4, 5\}
  2. 暴露范围 \(N\)受影响的记录数量，泄露 1000 条比泄露 1 条严重。
    N=受影响记录数N = \text{受影响记录数}
  3. 相乘得到泄露影响提醒我们既要降敏感度，也要控制暴露面。
    Ileak=C×NI_{\text{leak}} = C \times N

6. 拒绝服务（DoS）：堵住大门不让人进出

有人把一整卡车快递箱堆在你家门口，主人回不了家，客人进不来。拒绝服务攻击的目标，就是让你的 AI 系统“有服务等于没服务”。

AI 系统面临的 DoS 多种多样：API 被刷爆，请求队列排到天亮；一个超长输入让大模型算到超时；训练作业占满 GPU，在线推理被饿死。云上 AI 服务尤其脆弱，因为算力是共享的。

缓解手段包括限流、负载均衡、异常流量检测和降级预案。要衡量可用性，看正常服务时间占总时间的比例即可。

门口派保安、通道做闸机、货梯限流，AI 服务的门口也一样。别让一次攻击就能把整栋房子堵死。

A=TupTup+Tdown×100%A = \displaystyle \frac{T_{\text{up}}}{T_{\text{up}} + T_{\text{down}}} \times 100\%
99.9% 的可用性听着很美，折算下来一年可能仍有近 9 小时不可用。
  1. \(T_{\text{up}}\) 表示正常服务时长系统能响应用户请求的时间。
    Tup=正常运行小时数T_{\text{up}} = \text{正常运行小时数}
  2. \(T_{\text{down}}\) 表示不可用时长被攻击或故障导致的停机时间。
    Tdown=停机小时数T_{\text{down}} = \text{停机小时数}
  3. 相除并乘以 100% 得到可用率分子分母的观测周期必须一致。
    A=TupTup+TdownA = \frac{T_{\text{up}}}{T_{\text{up}} + T_{\text{down}}}

7. 权限提升（EoP）：保洁员捡到了管家钥匙

保洁员只该打扫客厅，却捡到管家遗落的钥匙，打开了保险库。权限提升威胁，就是攻击者从低权限角色一步步拿到高权限能力。

AI 系统里，权限提升经常长这样：提示注入诱导模型调用管理员工具；普通用户通过 API 漏洞读取其他租户的模型权重；低权限的 Agent 被越权赋予系统级操作权限。“大模型代理”的出现，让权限控制变得更加关键。

缓解的核心是权限隔离和最小特权：给每个角色、每个 Agent 只发够用的钥匙，并把高危操作放进沙箱。判断是否越权可以看实际权限与允许权限的差值。

把管家钥匙挂在墙上不是重点，重点是一把钥匙只能开对应的锁。权限提升威胁的解法，就是把“钥匙”和“锁”的关系设得足够细。

ΔL=L实际−L允许>0⇒越权\Delta L = \displaystyle L_{\text{实际}} - L_{\text{允许}} > 0 \Rightarrow \text{越权}
权限差值大于 0，说明实际掌控的权限已经超出了原本被授予的边界。
  1. 实际权限 \(L_{\text{实际}}\)攻击者实际获得的权限等级。
    L实际=5L_{\text{实际}} = 5
  2. 允许权限 \(L_{\text{允许}}\)系统允许该角色拥有的最高等级。
    L允许=2L_{\text{允许}} = 2
  3. 差值大于 0 判定越权差值为 0 或负数时，操作仍在许可范围内。
    ΔL=5−2=3>0\Delta L = 5 - 2 = 3 > 0

8. 清单与缓解：把防贼经验写进复查表

安全顾问离开前，留下了一张表：每种威胁对应一种防护措施，每季度复查一次。你的 AI 系统也需要这样一张 STRIDE 威胁识别清单。

清单可以按组件和数据流逐项打勾：外部输入？检查 Spoofing 和 DoS；跨信任边界？检查 Tampering 和 Info Disclosure；涉及特权操作？检查 EoP；没有日志？补 Repudiation。每个威胁类别都有成熟的缓解方向，比如认证、完整性校验、审计、加密、限流、权限隔离。

不过，安全不是一次性的。新功能上线、模型更新、数据源变化都会打开新的风险口。缓解措施总有不足，残余风险需要被持续监控。

房子会有新窗户，AI 系统会有新接口。每次变化后重新画图、重新查清单，威胁建模才能从一次体检变成终身健康管理。

R残余=R初始×(1−E缓解)R_{\text{残余}} = \displaystyle R_{\text{初始}} \times (1 - E_{\text{缓解}})
缓解效率再高，也只能把残余风险降低到可接受水平，很难完全归零。
  1. \(R_{\text{初始}}\) 表示缓解处理前的风险值由可能性和影响乘积得到。
    R初始=P×IR_{\text{初始}} = P \times I
  2. \(E_{\text{缓解}}\) 表示缓解措施的有效率取值范围 0 到 1。
    E缓解=0.9E_{\text{缓解}} = 0.9
  3. 1 减去缓解效率得到未缓解比例风险永远与系统并存，所以要持续迭代。
    R残余=R初始×0.1R_{\text{残余}} = R_{\text{初始}} \times 0.1

AI 应用场景

场景一：银行语音客服的防冒充升级

阶段：AI 应用部署与红队测试

解决的问题：传统客服仅凭声纹或密码验证，AI 合成语音能模仿客户音色，存在 Spoofing 风险。红队用 STRIDE 分析后，引入多因子“声纹 + 动态验证码 + 话术反问”，整体冒充概率从单因子的 10% 降到 0.1%。

具体案例：某银行语音助手被红队用开源 TTS 合成出客户声音，成功重置密码。修复后加入随机动态口令，并要求客户说出最近一笔交易金额。

场景二：大模型训练数据的投毒检测

阶段：数据准备与模型训练

解决的问题：训练数据来自爬虫和众包，无法保证不被篡改。利用 Tampering 威胁建模，在数据入库时计算哈希并记录来源，训练前对比外部备份，异常样本送入人工审核，降低数据投毒影响。

具体案例：某内容平台训练推荐模型时，发现一批带偏见的标注，由于每批数据都有哈希指纹，安全团队定位到具体上传者，并回滚该批次。

场景三：GPU 推理服务的抗 DoS 设计

阶段：模型上线与运维

解决的问题：大模型 API 每次推理都消耗大量算力，恶意刷接口可瞬间打爆 GPU。通过 DoS 建模，部署限流、队列长度控制和按用户并发配额，防止单个租户耗尽资源。

具体案例：某 SaaS 公司开放大模型 API 后遭遇异常请求洪峰，触发限流后服务可用性稳定在 99.95%，攻击流量被记录并拉黑。

Python 演示

python45 行
# -*- coding: utf-8 -*-"""STRIDE 威胁清单扫描器：根据组件属性生成威胁列表"""class STRIDEAnalyzer:    def __init__(self):        self.threats = []     def analyze(self, component):        risks = []        if component.get("external"):            risks.append(("Spoofing", "外部实体可能冒充合法用户"))            risks.append(("DoS", "外部可向系统发送大量请求"))        if component.get("cross_boundary"):            risks.append(("Tampering", "跨信任边界的数据可能被篡改"))            risks.append(("InformationDisclosure", "跨边界传输可能泄露数据"))        if component.get("privilege_escalation"):            risks.append(("ElevationOfPrivilege", "角色越过允许权限"))        if not component.get("audit", True):            risks.append(("Repudiation", "没有审计日志，动作不可追溯"))        for cat, desc in risks:            self.threats.append({                "component": component["name"],                "category": cat,                "description": desc,                "likelihood": component.get("likelihood", 3),                "impact": component.get("impact", 3),                "risk": component.get("likelihood", 3) * component.get("impact", 3)            })     def report(self):        for t in self.threats:            print(f"[{t['category']:^22}] {t['component']}: {t['description']} (风险={t['risk']})") if __name__ == "__main__":    analyzer = STRIDEAnalyzer()    components = [        {"name": "外部用户", "external": True, "cross_boundary": True,         "audit": False, "likelihood": 4, "impact": 4},        {"name": "API网关", "external": False, "cross_boundary": True,         "audit": True, "privilege_escalation": True, "likelihood": 2, "impact": 5},        {"name": "模型服务", "external": False, "cross_boundary": False,         "privilege_escalation": False, "audit": True, "likelihood": 3, "impact": 3},    ]    for comp in components:        analyzer.analyze(comp)    analyzer.report()
目的：把组件属性转成 STRIDE 威胁清单，并计算风险值，对应正文中的“威胁识别清单”。
  1. risks = []初始化当前组件的风险列表，避免污染上一个组件的结果。
  2. if component.get("external"):外部实体最容易引发冒充和拒绝服务，这是清单的第一条规则。
  3. if component.get("cross_boundary"):跨信任边界的数据流要重点检查篡改和信息泄露。
  4. if not component.get("audit", True):没有审计日志的组件要单独标记“抵赖”威胁。
  5. "risk": component.get("likelihood", 3) * component.get("impact", 3)用 R=P×I 公式计算风险分，优先处理高分项。

常见误区

误区我刚把 STRIDE 清单打了一遍勾，系统应该就安全了吧？以后不用再做了。

正解威胁建模不是一次性体检，而是持续过程。AI 系统会换模型、加接口、改数据源，每变化一次，攻击面就变一次。房子新开一扇窗，原来的防盗方案就要重新检查。

为何常见：清单看起来像静态检查表，容易让人误以为做完就打上“安全”标签，忽略了系统的动态演进。

误区Spoofing 是一种攻击手法，Tampering 是另一种攻击手法，我们只要记住这六个攻击工具就行。

正解STRIDE 是六类威胁结果，不是具体攻击技术。同样是 Spoofing，可以由 AI 变声、伪造证书、盗用 token 等多种方式造成。分类是为了穷举风险面，而不是替代具体攻击分析。

为何常见：STRIDE 的首字母缩写太像攻击代号，初学者容易把它们当成六个已知攻击剧本。

误区大模型内部什么也看不见，DFD 根本画不了，威胁建模对大模型没用。

正解DFD 不需要解释模型内部神经元，只需要把模型当作一个“处理组件”，画清它的输入、输出、调用者和信任边界。黑盒不影响建模，反而更需要在边界处加强防护。

为何常见：把“数据流图”误认为“系统内部结构图”，其实它描述的是组件之间可见的数据流动。

误区这个系统有十个威胁，那个系统只有三个，所以前者风险更高。

正解风险 = 可能性 × 影响。十个低危威胁加一起可能不如一个高危威胁严重。需要按资产价值、暴露程度和缓解成本排序，而不是数清单条目。

为何常见：数量容易被量化，大脑本能地拿“个数”当依据，但威胁建模的核心是严重度排序。

误区不管什么场景，把加密、多因子认证、日志审计全部拉满，肯定最安全。

正解过度防护会拖慢响应速度、伤害用户体验，还可能让合规流程变得寸步难行。安全是权衡的艺术，应该根据风险优先级选择性价比合适的缓解措施。

为何常见：人们倾向于把安全理解为“堆叠越多越安全”，却忽略了可维护性和可用性也是系统的重要属性。

面试题

Q1. STRIDE 中的字母 S 代表哪一类威胁？

单选题 · easy

  • A.冒充身份← 正确答案
  • B.篡改数据
  • C.拒绝服务
  • D.权限提升

答案：A。S 对应 Spoofing，即冒充合法身份。篡改数据是 T，拒绝服务是 D，权限提升是 E。

Q2. 数据流图中表示内外环境边界的虚线是什么？

单选题 · easy

  • A.信任边界← 正确答案
  • B.数据存储
  • C.处理节点
  • D.外部实体

答案：A。信任边界用虚线把可信区域与不可信环境分开，数据存储、处理节点、外部实体都是 DFD 中的元素，而不是边界本身。

Q3. 用 AI 合成老板声音骗过语音门禁，属于哪类威胁？

单选题 · easy

  • A.篡改数据
  • B.拒绝服务
  • C.冒充身份← 正确答案
  • D.权限提升

答案：C。合成声音是为了让系统误以为是老板，属于 Spoofing（冒充身份）。攻击者并没有篡改系统数据，也没有阻塞服务或提升自身权限。

Q4. 防止训练数据被投毒，最直接有效的措施是？

单选题 · mid

  • A.对数据做哈希校验← 正确答案
  • B.增大模型参数量
  • C.把学习率调成零
  • D.删除全部旧数据

答案：A。哈希校验可以快速发现数据是否被修改，对应 Tampering 的完整性防护。增大模型参数、调学习率、删数据都不能解决数据来源被篡改的问题。

Q5. 用户操作无日志、事后否认，对应 STRIDE 哪类威胁？

单选题 · mid

  • A.信息泄露
  • B.抵赖否认← 正确答案
  • C.篡改数据
  • D.拒绝服务

答案：B。没有日志或签名，用户就能否认自己的操作，这正是 Repudiation（抵赖）。信息泄露关注保密性，篡改关注完整性，DoS 关注可用性。

Q6. 成员推理攻击主要造成的威胁类别是什么？

单选题 · mid

  • A.信息泄露← 正确答案
  • B.权限提升
  • C.抵赖否认
  • D.拒绝服务

答案：A。成员推理通过模型输出判断某条数据是否在训练集中，属于敏感信息的间接泄露，对应 Information Disclosure。

Q7. 多因子认证降低冒充概率的数学原理是什么？

单选题 · hard

  • A.各因子概率相加
  • B.各因子概率相乘← 正确答案
  • C.只看最弱因子
  • D.概率不会变化

答案：B。多个认证因子需要同时被攻破，整体概率是各因子概率的乘积。每个因子概率都小于 1，连乘后迅速变小，因此多因子认证能显著降低 Spoofing 成功率。

Q8. 缓解效率 E 越高，残余风险会怎样变化？

单选题 · hard

  • A.跟随 E 一起升高
  • B.始终保持不变
  • C.随着 E 降低而降低← 正确答案
  • D.与 E 没有任何关系

答案：C。残余风险 = 初始风险 × (1 - E)。E 越接近 1，未消除的风险比例越小，所以残余风险越低，但通常不会完全归零。

Q9. 下列哪些措施能够缓解拒绝服务攻击？

多选题 · mid

  • A.接口限流← 正确答案
  • B.负载均衡← 正确答案
  • C.数字签名
  • D.流量异常检测← 正确答案

答案：ABD。限流控制请求速率，负载均衡分散压力，异常检测发现并隔离恶意流量，都能缓解 DoS。数字签名解决的是抵赖和完整性问题，与可用性无关。

Q10. 关于信任边界与 STRIDE，下列说法正确？

多选题 · extreme

  • A.跨边界数据流易被篡改← 正确答案
  • B.信任边界外不需要检查
  • C.边界内也存在内部威胁← 正确答案
  • D.STRIDE 只用于外部攻击

答案：AC。跨信任边界的数据流经过不可信区域，容易引入 Tampering 和 Info Disclosure；信任边界内并不天然安全，内部人员或失陷组件同样可能引发威胁。STRIDE 同时适用于外部和内部威胁。