开篇:EVM不是“执行完函数就结束”
在Solidity代码层面,我们经常把一次交易理解为:
调用函数 ↓执行代码 ↓修改状态 ↓返回结果
但EVM实际面对的是一个更复杂的执行过程:
交易进入EVM ↓创建调用帧 ↓读取Calldata ↓分配并扩展Memory ↓执行Stack指令 ↓读取或修改Storage ↓发起内部调用 ↓消耗Gas并建立新的调用帧 ↓成功提交,或沿调用链回滚
其中任何一个环节出现误判,都可能形成安全漏洞:
- Gas不足导致业务无法完成;
- 无界循环被用来制造拒绝服务;
- 调用栈过深导致内部调用失败;
- 外部调用把控制权交给恶意合约;
- 子调用失败被忽略,造成部分成功;
- 交易回滚让开发者误以为“所有影响都消失了”。
理解EVM执行模型,不能只看Solidity语法。需要同时理解:
- Gas;
- Stack;
- Memory;
- Storage;
- Calldata;
- Return data;
- Call frame;
- Revert;
- Commit。
一、一次EVM调用到底包含什么?
一笔普通合约交易,至少涉及以下上下文:
1. 交易级上下文
包括:
- 发送者;
- 目标地址;
value;data;- Gas上限;
- Gas价格或费用参数;
- 区块环境。
2. 调用帧级上下文
每次执行 call、delegatecall 或 staticcall,都会形成新的调用帧。
调用帧通常包含:
- 当前执行代码地址;
- 当前Storage所属地址;
msg.sender;msg.value;- 当前Memory;
- 剩余Gas;
- 返回数据;
- 当前调用深度。
这也是为什么 delegatecall 特别危险:它执行目标地址的代码,但使用当前合约的Storage上下文。
3. 状态级上下文
EVM执行期间,合约可能读取或修改:
- Storage;
- 账户余额;
- 合约代码;
- 日志;
- 自毁或账户状态。
如果最终执行成功,部分修改会提交。如果执行失败并触发回滚,当前交易范围内的状态修改通常会被撤销。
二、Gas机制:资源计费,也是攻击面
1. Gas解决什么问题?
区块链不能允许某个程序无限执行,否则任何人都可以提交永不结束的计算,占满所有节点资源。
Gas机制通过给每条指令设置成本,限制一次交易可以消耗的计算资源。
可以把交易可执行性粗略表示为:
GasUsed≤GasLimit
如果执行过程中消耗的Gas超过上限,交易会失败。
但这不意味着Gas只是交易费用。它还会影响:
- 循环能否执行完;
- 外部调用是否有足够资源;
- 批量操作能否成功;
- 恶意用户是否能制造DoS;
- 某个分支是否会因为Gas不足而不可达。
2. 固定循环与无界循环
固定规模循环通常较容易评估:
for (uint256 i = 0; i < 10; i++) { process(i);}
但下面的代码风险更高:
function distribute(address[] calldata users) external { for (uint256 i = 0; i < users.length; i++) { payable(users[i]).transfer(1 ether); }}
如果 users 数组由调用者控制,理论上调用者可以传入非常大的数组,使交易消耗大量Gas,最终无法完成。
更严重的是,如果这类函数承担了协议核心流程,例如:
- 结算奖励;
- 批量提款;
- 清算账户;
- 处理治理成员;
- 更新白名单;
攻击者可能通过持续增加数据规模,使整个功能永久无法执行。
这就是典型的Gas型拒绝服务。
3. 分批处理是工程上的常见解决方案
可以把单次处理改为带范围的分页执行:
function distribute( address[] calldata users, uint256 start, uint256 end) external { require(end <= users.length, "out of range"); require(end - start <= 100, "batch too large");
for (uint256 i = start; i < end; i++) { payable(users[i]).transfer(1 ether); }}
但分页并不自动解决所有问题,还要考虑:
- 同一个区间能否被重复处理;
- 处理进度是否持久化;
- 中途失败后如何重试;
- 单个恶意接收者是否会阻塞整个批次;
- 批次边界是否可以被篡改。
更健壮的设计往往采用“用户主动领取”:
function claim() external { uint256 amount = rewards[msg.sender]; require(amount > 0, "nothing to claim");
rewards[msg.sender] = 0; payable(msg.sender).transfer(amount);}
这样,协议不需要主动遍历所有用户,每个用户自行承担自己的调用成本。
三、Memory扩展:长度参数可能变成成本放大器
EVM的Memory是临时的、按字节寻址的内存区域。它不是固定大小,而是在访问更高偏移时动态扩展。
Memory扩展成本大致包含一个线性部分和一个二次增长部分,可以抽象表示为:
C(w)=a⋅w+⌊bw2⌋
其中:
- w 表示扩展后的Memory字数;
- a 和 b 是协议定义的成本参数;
- 当访问范围变大时,二次项会使成本增长更快。
攻击者可能控制:
- 动态数组长度;
bytes长度;- ABI编码偏移;
returndata复制长度;- 汇编中的内存指针;
- 哈希输入大小。
例如,低级汇编中如果直接使用用户提供的长度:
assembly { let length := calldataload(4) calldatacopy(0, 36, length)}
如果没有严格限制 length,就可能触发极大的Calldata复制和Memory扩展。
安全边界至少应包括:
require(length <= MAX_LENGTH, "input too large");
同时需要确认:
offset + length是否溢出;- 数据是否真的位于Calldata范围内;
- 动态字段之间是否重叠;
- ABI解码结果是否符合预期。
四、Gas转发与外部调用:资源和控制权一起外流
1. 外部调用不只是“调用一个函数”
下面这行代码看起来很普通:
(bool ok, ) = target.call{value: amount}(data);
但它可能带来多个问题:
target可能是恶意合约;- 外部合约可以回调当前合约;
- 调用可能消耗大量Gas;
- 返回值可能为空或格式异常;
- 失败可能被忽略;
- 目标合约可能改变协议依赖的外部状态。
外部调用同时转移了两样东西:
- 执行控制权;
- 一部分剩余Gas。
2. 为什么“转发全部Gas”危险?
如果协议把大量Gas交给外部合约,外部合约就获得了更大的执行空间:
target.call{gas: gasleft()}(data);
这不一定直接构成漏洞,但会扩大:
- 重入路径;
- 回调复杂度;
- Gas消耗;
- 调用嵌套;
- 失败分支的不确定性。
过去常见的做法是人为限制转发Gas,例如:
target.call{gas: 5000}(data);
但Gas限制不能替代正确的状态设计。原因包括:
- 不同EVM操作成本可能变化;
- 被调用逻辑可能需要更多Gas;
- 限制过低可能造成合法业务失败;
- 低Gas并不能阻止所有回调和状态读取;
- 安全性不应依赖一个脆弱的数值常量。
更重要的防护仍然是:
Checks ↓Effects ↓Interactions
也就是先检查条件,再更新内部状态,最后与外部合约交互。
五、调用栈深度:递归、嵌套与意外失败
1. 什么是调用栈?
EVM执行外部调用时,会建立新的调用帧。调用帧记录当前执行环境,例如:
- 当前代码;
- 当前Storage上下文;
msg.sender;msg.value;- 剩余Gas;
- 返回位置。
如果调用链是:
A → B → C → D → E
每一层都可能继续调用其他合约。
EVM对调用深度存在限制。过深的嵌套调用可能失败,即使每个合约单独看都没有逻辑错误。
2. 为什么调用栈风险不容易发现?
因为调用深度可能来自外部协议,而不是当前代码直接写出来的递归。
例如:
协议A ↓聚合器B ↓DEX C ↓Hook D ↓代币E ↓另一个协议F
一个简单的代币转账,可能因为代币Hook、AMM回调或跨协议路由,形成复杂调用链。
如果某个内部调用失败,当前合约可能得到:
(bool success, bytes memory data) = target.call(payload);
此时:
success == false表示子调用失败;data可能包含错误数据;- 父调用是否回滚,取决于父合约如何处理。
3. 低级调用失败必须显式处理
危险写法:
target.call(data);completed = true;
即使 target.call(data) 失败,completed 仍可能被设置为 true。
正确的最低限度写法:
(bool success, bytes memory result) = target.call(data);require(success, "call failed");
completed = true;
如果业务允许部分失败,也必须记录失败状态:
(bool success, ) = target.call(data);
if (success) { completed[id] = true;} else { failed[id] = true;}
不能简单地把所有失败都吞掉。
六、状态回滚:哪些东西会恢复,哪些不会?
1. Revert通常回滚链上状态
如果执行过程中出现:
revert("invalid state");
或:
require(condition, "failed");
当前交易范围内的状态修改通常会回滚,包括:
- Storage写入;
- ETH余额变化;
- 代币余额更新;
- 日志事件;
- 子调用产生的状态变化。
例如:
function update() external { value = 100; emit Updated(100);
revert("rollback");}
交易失败后,value = 100不会保留,Updated事件也不会作为成功状态留在链上。
2. 子调用失败不一定让父调用失败
考虑:
function execute(address target, bytes calldata data) external { (bool ok, ) = target.call(data);
if (!ok) { emit CallFailed(target); }
executed = true;}
这里子调用失败被父合约捕获,父合约仍然继续执行。最终可能出现:
目标操作失败 ↓父合约继续运行 ↓主流程标记为已完成
这在批量任务中可能是合理设计,但在资产转移、跨链消息和清算流程中就可能造成严重状态错配。
审计时必须区分:
- “失败后整个交易必须回滚”;
- “允许单项失败,但必须记录并可重试”;
- “失败后可以忽略”。
第三种情况通常最危险。
3. 回滚不是现实世界的时间机器
链上状态回滚,并不代表所有外部影响都被抹除。
以下影响可能已经发生:
- 交易被节点接收;
- 监控系统记录了该交易;
- 搜索者分析了交易意图;
- 交易进入了待处理队列;
- 其他链下服务触发了预处理;
- Gas已经被消耗;
- 交易顺序已经影响了市场参与者。
因此,不能简单认为:
“交易最终Revert,所以没有风险。”
对于MEV、抢跑、清算机器人和链下自动化系统而言,一笔失败交易也可能泄露重要信息。
七、状态回滚与跨合约交互的陷阱
1. 外部调用成功,不等于业务成功
某些代币合约可能:
- 返回
true; - 返回空数据;
- 返回格式异常;
- 内部不更新余额;
- 扣除手续费;
- 触发转账税;
- 执行额外回调。
因此,不能只依赖低级调用的成功标志判断业务效果。
例如:
(bool ok, ) = address(token).call( abi.encodeWithSignature( "transfer(address,uint256)", recipient, amount ));
require(ok, "transfer failed");
这里的 ok 只能说明低级调用没有直接回滚,不一定说明:
- 收款人真的收到了足额资产;
- 代币状态发生了预期改变;
- 返回值符合ERC-20语义。
对于关键资产操作,需要结合标准兼容封装和余额变化进行验证。
2. 事件不能替代状态
事件只是日志,不是权限控制,也不是状态本身。
下面的代码即使发出了事件,也不代表转账完成:
emit TransferCompleted(to, amount);
如果实际资产操作失败,单纯记录成功事件会误导:
- 前端;
- 索引器;
- 监控系统;
- 会计系统;
- 跨链中继器。
事件应当在确认关键状态变化成功后发出。
八、典型攻击面:Gas型DoS
场景一:恶意接收者阻塞批量支付
function payAll(address[] calldata recipients) external { for (uint256 i = 0; i < recipients.length; i++) { (bool ok, ) = recipients[i].call{value: 1 ether}(""); require(ok, "payment failed"); }}
如果其中一个接收者是恶意合约,并在回退函数中主动回滚,整个批量支付都会失败。
攻击者不一定需要窃取资产,只要让关键流程无法完成,就可能形成拒绝服务。
解决方向包括:
- 采用用户主动领取;
- 不因单个接收者失败而阻塞全局;
- 记录失败项并允许重试;
- 限制批次规模;
- 把资产转移和状态结算拆开。
场景二:可增长数组导致永久不可执行
address[] public users;
function processAll() external { for (uint256 i = 0; i < users.length; i++) { _process(users[i]); }}
如果任何人都可以向 users 中加入地址,数组增长到一定规模后,processAll()可能始终超过Gas限制。
更危险的是,如果协议没有分页、删除或领取机制,问题可能无法通过普通交易修复。
九、如何在Foundry中验证这些行为?
一个简单的Gas边界测试可以记录不同输入规模下的消耗:
function testGasForBatch(uint256 count) public { count = bound(count, 1, 100);
address[] memory users = new address[](count);
uint256 gasBefore = gasleft(); victim.process(users); uint256 gasUsed = gasBefore - gasleft();
emit log_named_uint("count", count); emit log_named_uint("gasUsed", gasUsed);}
重点不是只测一个输入,而是观察Gas增长趋势:
输入规模增加 ↓循环次数增加 ↓外部调用增加 ↓Memory与Storage成本增加 ↓交易接近Gas上限
还可以使用模糊测试检查协议是否在合理输入范围内保持可执行:
function testFuzz_BatchDoesNotExceedLimit( uint256 count) public { count = bound(count, 1, MAX_BATCH_SIZE);
address[] memory users = _makeUsers(count); victim.process(users);}
测试时要注意:不能只验证“交易没有Revert”,还要验证:
- 所有预期用户是否都被处理;
- 失败项是否被记录;
- 处理进度是否正确;
- 重复执行是否会重复发放;
- 中途失败能否恢复。
十、审计时的EVM执行检查清单
Gas与资源
- 是否存在无界循环?
- 循环规模是否由用户控制?
- 是否存在高成本Storage写入?
- 动态数组和Bytes长度是否受限?
- Memory偏移和复制长度是否经过校验?
- 批量操作是否支持分页?
- 单个用户失败是否会阻塞全局?
调用与控制流
- 是否存在外部调用?
- 外部调用前是否更新关键状态?
- 是否检查低级调用返回值?
- 是否验证返回数据格式?
- 是否使用了危险的
delegatecall? - 调用链是否可能过深?
- 是否存在跨函数或跨合约重入?
回滚与一致性
- 子调用失败后父函数是否继续执行?
- 失败状态是否记录?
- 事件是否可能早于实际状态变化发出?
- 部分成功是否会造成账务不一致?
- 跨链消息是否可能被标记为已执行但实际未完成?
- 交易回滚后是否有链下系统已经采取行动?
业务层
- Gas失败是否会影响清算、提款或治理?
- 外部代币是否可能收取手续费?
- 价格读取和资产转移之间是否存在状态变化?
- 依赖的第三方合约是否可能升级或暂停?
- 是否存在“成功返回但业务结果不正确”的情况?
结语:EVM安全的核心是控制执行边界
Gas、调用栈和状态回滚看起来属于EVM基础知识,但它们直接决定了智能合约是否可靠。
可以把三者概括为:
- Gas决定一次操作能否完成;
- 调用栈决定控制流能扩展到多深;
- 回滚决定失败后哪些状态能够恢复。
而智能合约的真实风险,往往来自三者的组合:
用户可控输入 ↓无界循环或大规模Memory扩展 ↓Gas不足 ↓内部调用失败 ↓失败被忽略 ↓状态与业务结果不一致
或者:
外部调用 ↓控制权转移 ↓恶意回调 ↓重入或深层嵌套 ↓部分状态更新 ↓回滚范围与预期不一致
因此,审计智能合约时不能只看“函数最终返回什么”,还要追踪:
- 消耗了多少资源;
- 创建了多少调用帧;
- 哪些状态已经修改;
- 哪些失败被捕获;
- 哪些外部系统已经观察到执行结果;
- 交易失败后,协议是否仍处于一致状态。
这才是理解EVM执行模型的真正意义:不是记住几个Opcode,而是能够判断一段代码在资源、控制流和状态生命周期上的完整安全边界。
413



被折叠的 条评论
为什么被折叠?



