15.3.1 EVM 架构与执行模型
所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.3 以太坊与 EVM
本节要解决的问题
很多人面试时把 EVM 说成"以太坊虚拟机,跑 Solidity"。这是表象。真正的分水岭是:能不能说清 EVM 的四区模型(栈、内存、存储、calldata)各自的生命周期、字长、Gas 成本,以及为什么 Solidity 要区分 storage/memory/calldata。本节解决四个具体问题:一是分清 EVM 是栈式虚拟机而不是寄存器式,256 位字长为什么是这个怪数;二是讲清 JUMP/JUMPDEST 与字节码有效性的关系,为什么不能跳进 PUSH 的数据段;三是把 CALL/DELEGATECALL/STATICCALL 的上下文差异串成一条可以现场推演的因果链;四是说明 CREATE/CREATE2 时 initcode 与 runtime code 的两段式结构,以及合约地址是怎么算出来的。
学习目标
学完本节,你应当能够:
- 画出 EVM 四区模型的示意图,标注每区的访问单位、生命周期、典型操作码与相对 Gas 量级。
- 在白板上写出栈式虚拟机的 PUSH/POP/DUP/SWAP 操作,并解释为什么栈深限制在 1024。
- 区分四种调用指令(CALL/CODECALL/DELEGATECALL/STATICCALL)对
address(this)、msg.sender、余额、状态写入权限的影响。 - 推演 CREATE2 时地址 = keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:],并说明 clash 风险。
先修与前置
- 建议先读 15.1.3 UTXO 与账户模型,理解账户模型下合约就是一个带代码与存储的账户。
- 本节是 15.3.2 Gas 计量与存储成本 与 15.3.3 ABI 编码与调用栈 的执行模型前置,先建立"四区 + 调用"再看 Gas 与编码。
知识地图
EVM 执行环境(每个交易/调用一份)
┌──────────────────────────────────────────────┐
│ 栈 Stack : 1024 深 × 256 位,后进先出,临时值 │
│ 内存 Memory : 字节数组,交易结束即丢弃,MLOAD/MSSTORE │
│ 存储 Storage: 2^256 槽 × 32 字节,持久化,SLOAD/SSTORE │
│ Calldata : 输入字节流,只读,CALLDATA* 系列 │
└──────────────────────────────────────────────┘
↑ 操作码按顺序执行,PC 自增,遇 JUMP/JUMPDEST 跳转
↑ 每步预扣 Gas,不足即整个调用 revert
调用上下文栈(最多 1024 层)
EOA → A.call → B.delegatecall → C.staticcall
每一层都有自己的 stack/memory/calldata/storage
storage 归属由调用类型决定(CALL=被调用者,DELEGATECALL=调用者)
合约创建两段式
initcode(执行构造函数)→ RETURN 输出 runtime code → 存入链上
核心术语
- 栈式虚拟机(Stack Machine):操作数都在栈上,没有寄存器;EVM 的每个字是 256 位,因为要匹配 Keccak-256 的哈希宽度。
- 栈(Stack):最多 1024 个 256 位字,PUSH/POP/DUP/SWAP 操作;溢出或下溢立即 revert。
- 内存(Memory):可读写的字节数组,按字扩展,交易结束即销毁;扩展成本随已用大小二次增长。
- 存储(Storage):2^256 个 32 字节槽,持久化在合约账户上;读写都很贵(SLOAD 量级约 100 Gas,SSTORE 量级约 2 万 Gas)。
- Calldata:调用输入的只读字节流,包含 selector 与参数;外部函数参数默认按 calldata 传递。
- JUMPDEST:合法跳转目标的标记,PC 必须落在 JUMPDEST 上才能跳转,不能跳进 PUSH 数据段。
- DELEGATECALL:在调用者的存储/余额/上下文里执行被调用合约的代码,常用于代理模式。
- STATICCALL:禁止状态写入与发币的调用,用于 view 函数与只读调用。
- CREATE2:带 salt 的确定性合约创建,地址 = keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:]。
- initcode / runtime code:创建时执行的字节码叫 initcode(含构造函数),RETURN 输出的才是部署到链上的 runtime code。
覆盖范围
- 四区模型的字长、生命周期、访问单位与成本量级
- 栈操作码(PUSH/POP/DUP/SWAP)与栈深限制
- JUMP/JUMPDEST 与字节码有效性校验
- 四种调用指令的上下文差异(CALL/CODECALL/DELEGATECALL/STATICCALL)
- 调用栈深度限制(1024)与失败传播
- CREATE/CREATE2 的地址推导与两段式部署
- 执行时环境信息(block.、msg.、tx.*)与时间戳操纵边界
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 15.3.1-001 | EVM 的栈、内存、存储、calldata 四区模型有什么区别? | 基础 | ★★★★★ |
| 15.3.1-002 | 为什么 EVM 字长是 256 位而不是 64 位?栈深为什么限制在 1024? | 基础 | ★★★★ |
| 15.3.1-003 | JUMP 为什么不能跳进 PUSH 数据段?JUMPDEST 是怎么校验的? | 基础 | ★★★★ |
| 15.3.1-004 | CALL、CODECALL、DELEGATECALL、STATICCALL 的区别? | 进阶 | ★★★★★ |
| 15.3.1-005 | DELEGATECALL 为什么能做代理升级?它的 msg.sender 是谁? | 进阶 | ★★★★★ |
| 15.3.1-006 | 调用栈深度 1024 限制是什么?超限会怎样? | 进阶 | ★★★ |
| 15.3.1-007 | CREATE 和 CREATE2 的地址怎么算?initcode 与 runtime code 区别? | 进阶 | ★★★★ |
| 15.3.1-008 | CREATE2 的 clash 是什么?什么时候会撞地址? | 高级 | ★★★ |
| 15.3.1-009 | block.timestamp 能被矿工操纵吗?边界在哪? | 高级 | ★★★★ |
| 15.3.1-010 | EOF(EVM Object Format)解决了传统字节码的什么问题? | 高级 | ★★★ |
15.3.1-001 EVM 的栈、内存、存储、calldata 四区模型有什么区别?
一句话结论
EVM 是一个四区栈式虚拟机:栈是 1024 深的 256 位临时值栈,内存是可读写的字节数组(交易结束即销毁),存储是 2^256 个 32 字节槽(持久化且昂贵),calldata 是只读输入字节流。四区的生命周期、访问单位、Gas 成本完全不同,这是 Solidity 必须区分 storage/memory/calldata 的根本原因。
概念解释
- 栈:操作数都在栈上,PUSH 立即数压栈,POP 丢弃,DUP n 复制栈顶第 n 个,SWAP n 交换栈顶与第 n 个;栈深 1024,溢出即 revert。
- 内存:按字节寻址,但 MLOAD/MSSTORE 一次读写 32 字节;新扩展内存要付扩展费(二次增长)。
- 存储:按 32 字节槽寻址,SLOAD 读、SSTORE 写;每个槽独立定价,首次写入最贵,清零有 refund。
- Calldata:CALLDATALOAD/CALLDATASIZE/CALLDATACOPY 读;不可写,参数传递用,比 memory 便宜。
原理流程
- 交易进入 EVM 时,创建一个全新的执行上下文:空栈、空内存、空 calldata 缓冲(从交易数据填充)、指向当前合约的存储。
- PC 从 0 开始顺序执行操作码;每条操作码先扣 Gas,再执行;Gas 不足立即整个调用 revert。
- 计算需要临时值时压栈;需要大块字节缓冲(如返回值、keccak 输入)时用 memory;需要跨交易保存状态时写 storage。
- 调用子合约时,子合约有自己的栈/内存/calldata,但 storage 归属由调用类型决定(CALL 是子合约自己的,DELEGATECALL 是调用者的)。
- 执行结束(STOP/RETURN/REVERT/SELFDESTRUCT)时,栈与内存销毁,storage 的修改视成功或回滚决定是否保留。
代码或图示
四区对比表:
区域 寻址单位 生命周期 典型操作 Gas 量级
栈 256 位字 调用内 PUSH/POP/DUP 3
内存 字节 交易内 MLOAD/MSSTORE 3 + 扩展费
存储 32 字节槽 持久化 SLOAD/SSTORE 100 / 20000
Calldata 字节 调用内(只读) CALLDATALOAD 3
Solidity 视角:
uint storage x; // SLOAD/SSTORE,贵
uint memory y; // MLOAD/MSSTORE,临时
function f(uint calldata z) external; // 直接读 calldata,最省
常见误区
- 误区:内存和存储都是"内存";正解:内存易失、按字节扩展、二次成本;存储持久、按槽定价、首次写入极贵。
- 误区:栈上也能放任意大小数据;正解:栈每个槽固定 256 位,字节串要先放进内存再把地址压栈。
- 误区:calldata 就是 memory 的只读版;正解:calldata 是调用方直接传进来的字节流,不需要 EVM 再拷贝一份,因此 external 函数用 calldata 参数比 memory 便宜。
追问
- 为什么栈是 1024 深?答:这是早期设计时选的一个上界,防止恶意合约通过无限递归把 Gas 烧光。机制上每次 CALL 会新建一个空栈,调用链总深度受 1024 限制。边界在于:1024 是"调用栈深度",不是"单个合约内栈深度",单个合约内栈也受 1024 限制。延伸:EIP-170 限制合约代码体积 24KB,与栈深限制共同限制极端合约。
- 内存扩展为什么是二次成本?答:为了防止"一次性扩展极大内存"的 DoS,让扩展成本随已用大小平方增长。机制上公式是 gas = 3 × words + words × words / 512。边界在于:实际合约很少扩展到上百 KB,二次成本在工程上很少被触发。延伸:这也是为什么大返回值要分批而不是一次性拼到内存里。
- storage 的 2^256 个槽真的能用满吗?答:不能,也不需要;SSTORE 首次写一个槽约 2 万 Gas,把链上所有槽写一遍成本远超任何经济激励。机制上槽位是稀疏的,未写过的槽读出来是 0。边界在于:mapping 用 keccak(key) 计算槽位,天然散列在 2^256 空间里,碰撞概率可忽略。延伸:storage 模型本质是一个巨大的稀疏键值表。
15.3.1-002 为什么 EVM 字长是 256 位而不是 64 位?栈深为什么限制在 1024?
一句话结论
EVM 选 256 位字长是为了与 Keccak-256 哈希原生对齐,栈上的值天然就是哈希输出的宽度,哈希计算不需要转换;栈深限制 1024 是一个早期拍板的 DoS 防护上界,防止恶意合约通过无限递归把 Gas 烧光,同时让客户端实现时栈可以预分配固定大小。
概念解释
- 256 位:Keccak-256 的输出就是 32 字节,EVM 的栈字、storage 槽、内存字都是 32 字节,哈希一次 MLOAD 出来的值直接就是栈上的一个字,零转换。
- 栈深 1024:单个执行上下文的栈最多 1024 个 256 位字;CALL 会新建一个空栈,调用链总深度也受 1024 限制。
- DoS 防护:如果栈无限制,攻击者可以写一个疯狂压栈的合约,把所有节点的内存耗尽。
- 客户端实现:固定大小的栈可以用数组预分配,边界检查简单。
原理流程
- 选 256 位的动因:以太坊需要哈希(交易、区块、Merkle 树、签名),哈希输出是 256 位;如果栈是 64 位,一次哈希要拆成 4 个字操作, Gas 成本与复杂度都上升。
- 同时 256 位也意味着地址(20 字节)可以放在一个栈字里高位补零,ECDSA 公钥坐标(256 位)也是一个字。
- 栈深限制:在黄皮书早期设计时,需要选一个"足够大但又不可能被滥用"的数;1024 是一个整数选择,单栈深度与调用栈深度都用它。
- 运行时每次 PUSH 前检查栈大小,超过 1024 立即 revert;每次 POP/DUP/SWAP 检查栈下溢。
代码或图示
256 位字长对齐:
keccak256 输出 = 32 字节 = 一个栈字
地址 20 字节 = 栈字高位补 12 字节 0
secp256k1 公钥坐标 = 两个 32 字节 = 两个栈字
栈操作码示例(PC 从 0 开始):
PC0: PUSH1 0x01 → 栈 [1]
PC2: PUSH1 0x02 → 栈 [1, 2]
PC4: ADD → 栈 [3]
PC5: PUSH1 0x03 → 栈 [3, 3]
PC7: DUP1 → 栈 [3, 3, 3]
PC8: SWAP1 → 栈 [3, 3, 3](栈顶两个相同,无视觉差异)
PC9: POP → 栈 [3, 3]
常见误区
- 误区:EVM 是 64 位虚拟机;正解:EVM 是 256 位栈式虚拟机,字长 32 字节。
- 误区:栈深限制是"每个合约内";正解:单个执行上下文栈深 1024,调用栈深度(嵌套 CALL 层数)也是 1024。
- 误区:256 位是因为 Solidity 用 uint256;正解:是反过来的——EVM 先选了 256 位,Solidity 才把 uint256 作为基本类型。
追问
- 256 位带来什么成本?答:所有算术都按 256 位实现,虽然现代 CPU 是 64 位,需要 4 个 64 位寄存器拼接。机制上 EVM 客户端(如 geth)用 big.Int 或 4 个 uint64 模拟 256 位运算。边界在于:简单算术(ADD/MUL)在 256 位实现下比 64 位贵,但 Gas 已经把这个成本内部化了。延伸:EWASM/eWASM 与 EOF 都在重新评估这个字长。
- 栈深 1024 够用吗?答:业务合约极少超过几十层调用;1024 是安全余量。机制上大多数合约调用链(钱包 → 路由 → 池子 → 代币)只有 5-10 层。边界在于:递归合约(如斐波那契递归)很容易触发栈深限制,工程上要改迭代。延伸:这也是为什么 Solidity 递归函数不推荐。
- 为什么不直接用寄存器式虚拟机?答:寄存器式(如 x86、ARM)需要编码寄存器号,指令变长、解码复杂;栈式指令密度高,实现简单,跨客户端一致性容易保证。机制上栈式 VM 的操作码不需要指定操作数位置,操作数就是栈顶。边界在于:栈式代码密度高但执行效率不如寄存器式,EVM 是为了共识一致性而非峰值性能设计的。延伸:Solana 的 BPF 是寄存器式,性能更高但共识复杂度也更高。
15.3.1-003 JUMP 为什么不能跳进 PUSH 数据段?JUMPDEST 是怎么校验的?
一句话结论
EVM 的字节码在部署时会扫描一遍,记录所有 JUMPDEST 操作码的 PC 位置,形成一个"合法跳转目标集合";运行时 JUMP/JUMPI 只能跳到集合内的 PC,不能跳进 PUSH 立即数的数据段(因为那是数据不是代码)。这个校验在部署时(initcode 执行时)一次性完成,运行时跳转前再查一次表。
概念解释
- JUMP:无条件跳转,栈顶给出目标 PC。
- JUMPI:条件跳转,栈顶是条件,次栈顶是目标 PC。
- JUMPDEST:占位操作码(0 Gas),标记一个合法跳转目标;PC 落在它上面才算合法。
- PUSHn:把后面 n 个字节作为立即数压栈;这些字节不是操作码,不能被 PC 当作指令执行。
- 字节码有效性:部署时扫描一遍,确保每个 PUSH 的数据段不被误当操作码;这个扫描结果是一个合法目标集合。
原理流程
- 合约部署时,EVM 执行 initcode,RETURN 输出 runtime code;runtime code 在存入链上之前先扫描一遍。
- 扫描从 PC=0 开始:遇到 JUMPDEST 就把 PC 加入合法目标集合;遇到 PUSHn 就跳过 n 个字节(这些是数据);其它操作码 PC 加 1。
- 运行时执行 JUMP/JUMPI:把栈上弹出的目标 PC 与合法目标集合比较,不在集合内立即 revert。
- 这保证了:你永远不会跳进 PUSH 的数据段,因为扫描时 PUSH 的数据段里即使有 JUMPDEST 的字节,也不会被加入集合。
代码或图示
字节码示例:
PC0: PUSH1 0x04 → 0x60 0x04(2 字节)
PC2: JUMP → 0x56
PC3: JUMPDEST → 0x5B(PC=3)
PC4: STOP → 0x00
扫描:
PC=0 是 PUSH1,跳过 1 字节 → PC=2
PC=2 是 JUMP(不加入集合)→ PC=3
PC=3 是 JUMPDEST,加入集合 → PC=4
PC=4 是 STOP → 结束
合法目标集合 = {3}
如果有人 JUMP 到 PC=1(0x04,即 PUSH 的数据段):
1 不在集合 → revert
常见误区
- 误区:JUMP 可以跳到任意 PC;正解:只能跳到 JUMPDEST 标记的位置。
- 误区:PUSH 的数据段里如果有 JUMPDEST 字节也算合法目标;正解:扫描时 PUSH 数据段被整体跳过,里面即使是 0x5B 字节也不算 JUMPDEST。
- 误区:JUMPDEST 是运行时校验的;正解:合法目标集合在部署时一次性计算,运行时只查表。
追问
- 为什么要设计这个限制?答:为了让字节码有唯一的"指令流",避免解析歧义;同时防止构造出"反编译不一致"的字节码。机制上没有这个限制,一段字节码可能从不同 PC 开始解码出不同的指令流,跨客户端共识会出问题。边界在于:这个设计也让"跳进数据段"这种混淆手段失效。延伸:这也是为什么 EOF 要把代码与数据分段。
- PUSH 数据段里的字节如果恰好是某个操作码会怎样?答:不会被执行,因为扫描时跳过了;它只是数据。机制上 EVM 的 PC 是"指令指针",只在操作码边界上移动。边界在于:运行时如果你用 CODECOPY 把这段数据拷贝到内存再执行,那是另一回事(EVM 不支持动态生成代码执行)。延伸:EVM 没有 eval 机制,这是共识安全的设计。
- JUMPDEST 为什么不花 Gas?答:它只是一个占位标记,运行时不做任何操作;扫描成本在部署时一次性付了。机制上 JUMPDEST 是 0x5B,执行时 PC 直接加 1,栈不变。边界在于:JUMPDEST 在部署扫描时被记录,运行时跳转查它;如果在运行时动态修改代码(SELFDESTRUCT 后的历史行为),集合会失效。延伸:EIP-6780 缩小了 SELFDESTRUCT 的影响范围。
15.3.1-004 CALL、CODECALL、DELEGATECALL、STATICCALL 的区别?
一句话结论
四种调用指令的核心差异在两点:一是 address(this) 与 storage 归属(CALL 是被调用者的,DELEGATECALL/CODECALL 是调用者的),二是 msg.sender 与写权限。CALL 是普通调用(转入被调用者上下文),DELEGATECALL 在调用者上下文执行被调用者代码(代理模式核心),STATICCALL 禁止写状态,CODECALL 已废弃(与 DELEGATECALL 相同但 msg.sender 不变)。
概念解释
- CALL:转入被调用合约上下文,
address(this)= 被调用者,storage 是被调用者的,msg.sender = 调用者,可写状态、可发币。 - CODECALL:已废弃,与 DELEGATECALL 类似但不保留 msg.sender(实际历史上行为模糊,不使用)。
- DELEGATECALL:在调用者的上下文里执行被调用者的代码,
address(this)= 调用者,storage 是调用者的,msg.sender 保持不变(还是原始 EOA)。 - STATICCALL:禁止状态写入与发币,其它同 CALL;用于 view 函数与只读调用。
- 2300 Gas stipend:CALL 转 ETH 时附带 2300 Gas,用于接收合约的 payable fallback。
原理流程
- 普通调用 A.call(B, data):A 把 data 传给 B,B 在自己的存储上执行,
address(this)= B,msg.sender = A;B 的状态修改影响 B。 - 代理调用 A.delegatecall(C, data):A 在自己的存储上执行 C 的代码,
address(this)= A,msg.sender 保持原始 EOA;C 的代码修改的是 A 的存储。 - 只读调用 A.staticcall(B, data):B 不能 SSTORE、不能发币、不能创建合约;用于 EOA 读 view 函数。
- 调用失败时:被调用合约 revert,所有状态修改回滚,但调用者可以选择是否把错误继续抛出去(低级 call 返回 false 而不是自动 revert)。
- Gas:调用者把剩余 Gas 的 63/64 给被调用者(EIP-150 调整),自己留 1/64。
代码或图示
上下文对比表:
指令 address(this) storage 归属 msg.sender 写权限 发币
CALL 被调用者 被调用者 调用者 可写 可
DELEGATECALL 调用者 调用者 不变(原始 EOA)可写 可(但转给调用者)
STATICCALL 被调用者 被调用者 调用者 禁止 禁止
CALLCODE 已废弃 调用者 调用者 可写 可(历史行为模糊)
Solidity 视角:
B(b).transfer() // CALL
B(b).delegatecall(data) // DELEGATECALL(低级)
B(b).staticcall(data) // STATICCALL(低级)
常见误区
- 误区:DELEGATECALL 调用的是被调用者的存储;正解:DELEGATECALL 用的是调用者的存储,被调用者只提供代码。
- 误区:STATICCALL 只是"view 函数";正解:它是 EVM 层面的硬限制,任何 SSTORE 直接 revert,不是 Solidity 编译器层面的约定。
- 误区:DELEGATECALL 后 msg.sender 变成代理合约;正解:msg.sender 保持原始 EOA 不变,这是代理模式能透传用户身份的关键。
追问
- 为什么代理模式用 DELEGATECALL 而不是 CALL?答:因为用户要与"代理合约"交互,代理把调用转发给实现合约,但状态要存在代理上(这样升级实现合约时代理的存储不变)。机制上 DELEGATECALL 让实现合约的代码在代理的存储上下文执行。边界在于:实现合约与代理的存储布局必须严格一致,否则升级时会读到错误的槽位。延伸:这就是 15.4.2 要讲的
__gap与 EIP-1967 标准槽位。 - STATICCALL 是怎么强制只读的?答:EVM 执行时如果检测到 STATICCALL 上下文里出现 SSTORE/CREATE/SELFDESTRUCT 就立即 revert。机制上"静态"标志会沿着调用链传递,子调用也不能写。边界在于:这是 EVM 运行时检查,不是编译期检查;即使合约代码里有 SSTORE,只要走 STATICCALL 就 revert。延伸:这让 eth_call 可以安全地模拟交易。
- 2300 Gas stipend 是干什么的?答:当 CALL 附带 ETH 转账时,接收合约的 payable fallback 会收到 2300 Gas,足够做一个事件日志,但不够做状态写入。机制上这是为了让"转账给合约"不会因为 fallback 写存储而 revert。边界在于:2300 Gas 量级只能打一个事件,不能做任何 SSTORE;如果接收方想做更多逻辑,必须用 call 转更多 Gas。延伸:这也是为什么 ERC-20 的 transfer 到合约地址要小心(如 Uniswap V2 的 uniswapV2Call 回调需要更多 Gas)。
15.3.1-005 DELEGATECALL 为什么能做代理升级?它的 msg.sender 是谁?
一句话结论
DELEGATECALL 让调用者在自己的存储、余额、上下文里执行被调用合约的代码,msg.sender 保持原始 EOA 不变。代理合约模式就是:用户调用代理合约,代理用 DELEGATECALL 把调用转发给实现合约,实现合约的代码操作代理的存储;升级实现合约地址时,代理的存储与用户身份都不变,只是换了代码。
概念解释
- 代理合约(Proxy):一个极简合约,只存实现合约地址与 admin,所有调用都 fallback 到 delegatecall。
- 实现合约(Implementation):真正的业务逻辑代码,不能有自己的存储(或存储布局与代理一致)。
- 上下文保留:DELEGATECALL 时
address(this)= 代理,msg.sender= 原始 EOA,msg.value= 原始调用的值。 - 存储布局一致:实现合约的 storage 变量顺序必须与代理(或代理预留的
__gap)一致,否则升级后读错槽位。
原理流程
- 用户 EOA 调用代理合约的
foo()函数。 - 代理合约没有
foo()函数,fallback 触发,读取实现合约地址,用 DELEGATECALL 把 calldata 转发给实现合约。 - 实现合约在代理的存储上下文里执行
foo(),msg.sender 仍是用户 EOA。 - 实现合约修改的状态都写到代理的存储槽里。
- 升级时,admin 只改代理里存的实现合约地址,下次调用就跑新代码,存储完全不变。
代码或图示
// 极简代理(示意,生产用 OpenZeppelin)
contract Proxy {
address public implementation;
address public admin;
function setImplementation(address impl) external {
require(msg.sender == admin);
implementation = impl;
}
fallback() external payable {
(bool ok, bytes memory ret) = implementation.delegatecall(msg.data);
assembly {
let size := returndatasize()
returndatacopy(0, 0, size)
switch ok case 0 { revert(0, size) } default { return(0, size) }
}
}
}
// 调用链:
// 用户 EOA → Proxy.foo() → fallback → delegatecall(Impl.foo)
// address(this) = Proxy
// msg.sender = 用户 EOA
// 存储 = Proxy 的槽位
常见误区
- 误区:DELEGATECALL 后 msg.sender 变成代理;正解:msg.sender 保持原始 EOA,这是代理模式透传用户身份的关键。
- 误区:实现合约的存储变量存在实现合约自己的地址上;正解:DELEGATECALL 时所有 SSTORE 都写到调用者(代理)的槽位。
- 误区:升级实现合约时要迁移数据;正解:数据一直在代理上,升级只换代码地址,数据零迁移。
追问
- 代理模式为什么会有存储冲突?答:代理自己也要存变量(实现地址、admin),如果这些槽位与实现合约的变量顺序重叠,就会互相覆盖。机制上代理的第一个槽是 implementation 地址,如果实现合约的第一个变量也存在槽 0,就会读到实现地址。边界在于:这就是 EIP-1967 用一个特殊槽位(keccak 算出来的随机位置)存 implementation 地址的原因。延伸:15.4.2 详细讲 Transparent/UUPS/Beacon。
- DELEGATECALL 能调任意合约吗?答:技术上能,但被调用合约必须存在;且被调用合约的代码会在你的上下文执行。机制上这意味着被调用合约可以读你的存储、用你的余额发币。边界在于:这是最大的安全风险——升级到恶意实现合约等于把钱包交给它。延伸:代理的 admin 权限必须多签 + timelock。
- 为什么不用直接 CALL 转发?答:因为 CALL 转发时存储是被调用者的,用户的余额与状态都存在实现合约上;升级实现合约时数据要迁移,且新用户要与新地址交互,历史地址失效。机制上 DELEGATECALL 让"地址不变,代码可换"成为可能。边界在于:这要求实现合约与代理存储布局严格一致,是工程上的硬约束。延伸:不可变合约(无代理)与可升级合约是两种哲学取舍。
15.3.1-006 调用栈深度 1024 限制是什么?超限会怎样?
一句话结论
EVM 限制一个交易内嵌套调用的总层数为 1024;超过后,最新一次 CALL 直接失败(返回 false,不消耗剩余 Gas 的概念)。这个限制是 DoS 防护,防止恶意合约通过无限递归把 Gas 烧光,同时让客户端实现时调用栈可以预分配固定大小。
概念解释
- 调用栈深度:从 EOA 开始,每一层 CALL/DELEGATECALL/CREATE 算一层,总层数 ≤ 1024。
- 超限行为:新 CALL 直接失败,返回 false,不执行被调用合约的任何代码;但调用者的状态已经修改的部分是否回滚取决于调用者怎么处理。
- Gas 调整:EIP-150 规定调用者只能把剩余 Gas 的 63/64 给被调用者,自己留 1/64,防止调用链把 Gas 烧光。
- 递归:Solidity 递归函数很容易触发 1024 限制,工程上要改迭代。
原理流程
- EOA 发起交易,深度 = 1。
- A.call(B) → 深度 = 2;B.call(C) → 深度 = 3。
- 每次 CALL 前 EVM 检查深度是否已经 1024;是则 CALL 失败,返回 false。
- 失败时被调用合约不执行任何代码,调用者收到 false;低级 call 不会自动 revert,调用者自己决定怎么处理。
- EIP-150 的 Gas 限制:调用者给被调用者的 Gas ≤ 剩余 Gas × 63/64,自己留 1/64;即使被调用合约疯狂消耗 Gas,也不会把调用者的 Gas 全部烧光。
代码或图示
// 递归合约:深度很容易超 1024
contract Recursive {
function fib(uint n) public pure returns (uint) {
if (n <= 1) return n;
return fib(n - 1) + fib(n - 2); // 递归调用,深度 = n
}
// fib(100) 深度 100,fib(1000) 直接超限 revert
}
// 低级 call 失败处理:
function safeCall(address target, bytes calldata data) external {
(bool ok, bytes memory ret) = target.call(data);
if (!ok) {
// 这里可以选择 revert 或降级处理
// 如果是栈深超限,被调用者根本没执行
}
}
常见误区
- 误区:栈深 1024 是指单个合约内的栈;正解:调用栈深度是指嵌套 CALL 层数,单个合约内的 EVM 数据栈深度也是 1024。
- 误区:栈深超限会把整个交易 revert;正解:低级 call 只返回 false,调用者可以选择继续;但如果调用者不检查,状态会不一致。
- 误区:EIP-150 的 63/64 是为了省钱;正解:是为了 DoS 防护,防止被调用合约把调用者的 Gas 烧光导致调用者无法处理错误。
追问
- 为什么是 1024?答:早期设计时拍板的一个足够大的数;业务合约实际调用链很少超过 20 层。机制上固定大小让客户端实现时调用栈可以用数组预分配。边界在于:1024 对递归合约是硬限制,工程上要避免递归。延伸:这也是为什么 Solidity 官方不推荐递归。
- 栈深超限与 Gas 不足有什么区别?答:Gas 不足是整个交易 revert,所有状态回滚;栈深超限是 CALL 失败返回 false,调用者可以选择继续或 revert。机制上两者都是"调用失败",但传播方式不同。边界在于:低级 call 不检查返回值时,栈深超限会被静默忽略,导致业务逻辑错误。延伸:生产代码必须
require(ok)。 - EIP-150 的 63/64 怎么计算?答:假设剩余 Gas = G,给被调用者的 Gas ≤ G × 63/64;调用者自己留至少 G/64。机制上这是"最后一跳保护",即使被调用合约把 Gas 全部烧光,调用者手里还有 1/64 的 Gas 可以处理错误。边界在于:这也意味着被调用者最多只能拿到 98.4% 的剩余 Gas,不能完全烧光。延伸:这是 DoS 防护的数学设计。
15.3.1-007 CREATE 和 CREATE2 的地址怎么算?initcode 与 runtime code 区别?
一句话结论
CREATE 的地址 = keccak256(rlp(deployer ++ nonce))[12:],nonce 递增,不可预知;CREATE2 的地址 = keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:],盐固定则地址固定。部署时先执行 initcode(含构造函数),initcode 的 RETURN 输出才是链上存的 runtime code。
概念解释
- CREATE:用 deployer 地址 + nonce 算地址,nonce 是 deployer 发出去的交易/合约创建计数;每次递增。
- CREATE2:用 deployer + salt + initcode 哈希算地址,与 nonce 无关;只要 salt 与 initcode 不变,地址可预测。
- initcode:部署时提交的完整字节码(含构造函数),执行一次后丢弃。
- runtime code:initcode 执行后 RETURN 输出的字节码,存入链上作为合约代码。
- clash:同一地址已经有合约代码或余额时,CREATE2 会失败。
原理流程
- EOA 发交易,data 字段是 initcode(含构造函数),to = 0。
- EVM 计算新合约地址:CREATE 用 rlp(deployer ++ nonce),CREATE2 用 0xff ++ deployer ++ salt ++ keccak256(initcode)。
- 在新地址上执行 initcode:构造函数跑,可能修改状态、发事件。
- initcode 执行 RETURN,返回的字节流就是 runtime code,存入新地址的 code 字段。
- 如果新地址已经有代码或余额,创建失败(CREATE2 还要检查 salt 是否被用过)。
代码或图示
CREATE 地址推导:
nonce 是 deployer 的发送计数(从 0 开始)
address = keccak256(rlp.encode([deployer, nonce]))[12:]
例:deployer = 0x1111...1111, nonce = 1
rlp([0x1111..., 1]) → 哈希 → 取后 20 字节
CREATE2 地址推导:
address = keccak256(
0xff ++ deployer ++ salt(32 字节) ++ keccak256(initcode)
)[12:]
// 0xff 前缀防止与 CREATE 地址冲突
// 只要 deployer、salt、initcode 不变,地址固定
两段式:
initcode = 构造函数字节码 + runtime code
执行 initcode → 构造函数跑 → RETURN 输出 runtime code
链上存的 = runtime code(initcode 本身不存)
常见误区
- 误区:部署时提交的 data 就是链上存的代码;正解:data 是 initcode(含构造函数),执行后 RETURN 输出的才是 runtime code。
- 误区:CREATE2 地址与 nonce 有关;正解:CREATE2 地址只与 deployer、salt、initcode 哈希有关,nonce 不影响。
- 误区:CREATE2 一定能部署成功;正解:如果目标地址已经有代码或余额(clash),创建失败。
追问
- CREATE2 为什么要在哈希里加 keccak256(initcode)?答:为了让地址不仅与 deployer+salt 有关,还与代码内容有关;这样不同 initcode 用同一 salt 部署到同一 deployer 不会撞。机制上 initcode 哈希被包含在地址推导里。边界在于:如果你用相同 deployer、相同 salt、相同 initcode 部署,第二次会 clash 失败。延伸:这就是 CREATE2 的"确定性"——你可以提前算出合约地址。
- 构造函数里的参数在哪里?答:构造函数的 ABI 编码参数追加在 initcode 末尾,运行时构造函数从 calldata 里读。机制上 initcode = 运行时字节码 + 构造函数参数编码。边界在于:构造函数参数影响 initcode 的哈希,因此影响 CREATE2 地址。延伸:这也是为什么 CREATE2 部署要固定构造参数。
- 为什么用 0xff 前缀?答:为了防止 CREATE 与 CREATE2 地址空间冲突;CREATE 的输入是 rlp(deployer ++ nonce),前缀是 0xd6 等 rlp 编码,与 0xff 不同。机制上 0xff 是一个不会出现在 rlp 编码里的前缀。边界在于:这保证两种创建方式不会算到同一个地址。延伸:这是密码学安全的分隔设计。
15.3.1-008 CREATE2 的 clash 是什么?什么时候会撞地址?
一句话结论
CREATE2 的 clash 是指目标地址已经有合约代码或余额时,新的创建会失败;撞地址发生在三种情况:同一 deployer+同一 salt+同一 initcode 重复部署、地址被预言机预先占用("合约前置"攻击)、或者历史巧合(概率可忽略)。
概念解释
- Clash:CREATE2 目标地址已经非空(有代码或余额)时,创建交易失败。
- 合约前置(Contract Front-running):攻击者提前算出 CREATE2 地址,用极少量 ETH 在该地址存一点余额,让受害者的 CREATE2 失败。
- Initcode 哈希:CREATE2 地址 = keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:];initcode 变了地址就变。
- Salt 复用:同一 deployer 用不同 salt 部署不同合约,地址不同;同一 salt 复用会 clash。
原理流程
- 部署方准备好 initcode 与 salt,准备 CREATE2 部署。
- 任何人都可以离线算出目标地址:keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:]。
- 如果攻击者先一步用极少量 ETH(或部署一个恶意合约)在该地址存东西,受害者的 CREATE2 交易就会失败。
- 防御方式:在部署前检查目标地址是否非空;或者用一次性 salt(包含部署者的随机数)。
- 另一种情况:同一 deployer 重复部署相同 initcode + 相同 salt,第二次必然 clash。
代码或图示
CREATE2 clash 场景:
受害者:deployer = 0xA, salt = 0xB, initcode = 0xC
目标地址 = keccak256(0xff ++ 0xA ++ 0xB ++ keccak256(0xC))[12:]
攻击者离线算出目标地址 0xD
攻击者先发一笔 1 wei 的交易给 0xD(地址现在有余额)
受害者部署时:0xD 已经有余额 → CREATE2 失败
防御:
1. 部署前 eth_getCode(0xD) == 0 且 eth_getBalance(0xD) == 0
2. 用一次性 salt(如 salt = keccak256(block.number ++ random_nonce))
3. 在部署交易里加 nonce 约束(只允许特定区块号部署)
常见误区
- 误区:CREATE2 一定能部署成功;正解:目标地址非空就失败。
- 误区:clash 只会发生在重复部署;正解:外部攻击者也可以预先占用目标地址。
- 误区:CREATE2 地址是随机的;正解:地址是密码学推导的,任何人都可以离线算出来。
追问
- 为什么会有人前置占用 CREATE2 地址?答:这是一种 DoS 攻击,让受害者的合约部署失败;通常发生在依赖 CREATE2 地址有特殊意义(如确定性部署、钱包工厂)的场景。机制上攻击者不需要破解什么,只需要离线算地址再发一笔极小交易。边界在于:这种攻击成本极低(1 wei),但成功率取决于攻击者是否监控到部署方的意图。延伸:钱包工厂(如 Safe)会用一次性 salt 防前置。
- 怎么防御 CREATE2 前置?答:用一次性 salt(如 salt = keccak256(block.timestamp ++ deployer 私钥签名的 nonce)),让攻击者无法提前预测。机制上 salt 不可预测,地址就不可预测。边界在于:如果 salt 可预测(如固定盐、固定区块号),前置就可行。延伸:生产用 CREATE2 都要带随机盐。
- CREATE2 与 CREATE 的安全性对比?答:CREATE 地址依赖 nonce,部署时无法提前预知,天然防前置;CREATE2 地址可预测,方便但引入前置风险。机制上 CREATE 的 nonce 是 deployer 自己控制的,外部无法预知。边界在于:CREATE2 的优势是"确定性部署"(跨链同地址),这是它被广泛使用的原因。延伸:Layer2 的确定性部署常用 CREATE2。
15.3.1-009 block.timestamp 能被矿工操纵吗?边界在哪?
一句话结论
PoS 下出块验证者可以在一定范围内选择区块时间戳(通常是当前时间前后 15 秒内),但不能任意设为过去或未来很久;block.timestamp(即 block.prevrandao 之前的 block.timestamp)不能用于强随机数(如抽奖),但可以用于时间窗口(如锁仓期到期)。
概念解释
- 时间戳:区块头里的 timestamp 字段,单位秒,验证者出块时设置。
- 操纵范围:新块时间戳必须大于父块时间戳,且不能大于验证者节点本地时间 + 15 秒(早期规则,具体以当前硬分叉参数为准)。
- 不能用做随机数:验证者可以在范围内选择,等于轻微可操纵。
- 可以用于时间窗口:锁仓到期、拍卖结束等场景,15 秒级别的偏差可以接受。
原理流程
- 验证者打包交易出块,设置 timestamp = 节点本地当前时间。
- 协议要求新 timestamp > 父块 timestamp,且不能超过本地时间太多(防未来时间攻击)。
- 验证者可以在一个小窗口内(约 15 秒)选择是否提前出块或等一会。
- 合约读
block.timestamp拿到的就是这个被轻微操纵过的时间。 - 如果合约用
block.timestamp做随机数(如uint(keccak256(block.timestamp)) % 100),验证者可以在窗口内选择对自己有利的值。
代码或图示
// 安全:时间窗口
contract Timelock {
uint public unlockTime;
function withdraw() external {
require(block.timestamp >= unlockTime, "locked");
// 即使验证者微调时间戳 15 秒,也只是早 15 秒,业务可接受
}
}
// 危险:用时间戳做随机数
contract Lottery {
function pickWinner() external view returns (uint) {
return uint(keccak256(abi.encodePacked(block.timestamp))) % 100;
// 验证者可以在 15 秒窗口内选择对自己有利的 timestamp
// 这就是经典的“时间戳操纵攻击”
}
}
常见误区
- 误区:block.timestamp 是精确的;正解:验证者可以在小窗口内选择,精度是秒级但可微调。
- 误区:block.timestamp 完全不可信;正解:时间窗口(锁仓、到期)场景完全可信,只是不能做强随机数。
- 误区:验证者可以把时间戳设成任意值;正解:必须大于父块,且不能超前本地时间太多。
追问
- 为什么时间戳不能做强随机数?答:因为验证者在出块时可以在小窗口内选择 timestamp,等于有轻微的选择权。机制上如果合约用
block.timestamp % N做随机,验证者可以等待一个对自己有利的时间戳再出块。边界在于:窗口只有约 15 秒,影响有限,但对高价值抽奖场景足够被利用。延伸:正确做法是用 VRF(可验证随机函数)或 commit-reveal。 - block.number 可信吗?答:block.number 是区块高度,由协议强制递增,验证者不能操纵;它是可信的"块序号"。机制上每个块高度固定,不能跳。边界在于:block.number 与时间的对应关系(出块时间)是浮动的(PoS 下约 12 秒/块,但有抖动)。延伸:要"时间窗口"用 timestamp,要"块序号"用 number。
- PoS 后时间戳规则变了吗?答:Merge 后出块权交给验证者,但时间戳的约束基本保留:新块必须大于父块,且不能超前本地时间太多。机制上 PoS 下出块间隔约 12 秒,验证者有更多灵活性但不是无限的。边界在于:具体参数(如 15 秒窗口)随硬分叉调整,工程上以当前黄皮书为准。延伸:这也是为什么合约安全文档明确说"不要用 block.timestamp 做随机数"。
15.3.1-010 EOF(EVM Object Format)解决了传统字节码的什么问题?
一句话结论
EOF 把合约字节码分成"代码段"与"数据段"两部分,引入验证版本、类型化栈、跳转为相对偏移,解决传统字节码"代码与数据混在一起、反编译不一致、JUMPDEST 扫描开销大"的问题。目前 EOF 正在分阶段部署(EIP-3540/3670/4200 等),主网尚未完全启用。
概念解释
- EOF(EVM Object Format):EIP-3540 提出的新字节码格式,把代码段与数据段分开。
- 传统字节码:代码与数据混在一起,JUMPDEST 扫描时要区分 PUSH 数据段与指令。
- 类型化栈:EOF 引入栈上值的类型标记(如是否是代码地址、是否是外部账户),减少校验开销。
- 相对跳转:EOF 用 RJUMP(相对跳转)代替 JUMP(绝对 PC),跳转目标计算更简单。
- 分段:EOF 合约可以有多个代码段(如 EOF 容器),数据段独立存储。
原理流程
- 传统字节码:代码与数据是一个字节流,JUMPDEST 扫描时要从头走一遍,区分 PUSH 数据段。
- EOF 设计:字节码开头有一个 header,标明有几个代码段、数据段多大;每个代码段独立。
- 代码段里的跳转用 RJUMP(相对偏移),不需要 JUMPDEST 扫描。
- 数据段(如常量、元数据)独立存放,不能被 PC 当指令执行。
- 好处:部署时代码验证更快(不用全量扫描),反编译更一致,支持更安全的合约分段。
代码或图示
传统字节码(代码与数据混合):
[PUSH1 0x04][JUMP][JUMPDEST][STOP][0x60 0x01]
↑数据段里的字节可能被误当指令
EOF 字节码(代码段与数据段分离):
header: version=1, code_section_count=1, data_section_size=2
code_section:
[RJUMP 0x02][STOP]
data_section:
[0x60 0x01] ← 纯数据,不能被执行
跳转用相对偏移,不需要 JUMPDEST 扫描
常见误区
- 误区:EOF 已经全面上线;正解:EOF 分阶段部署,主网启用进度以当前 EIP 状态为准。
- 误区:EOF 只是优化 Gas;正解:EOF 是字节码格式的重构,影响部署、验证、反编译全链路。
- 误区:现有合约会自动升级;正解:EOF 是 opt-in,老合约继续按传统格式执行。
追问
- EOF 为什么要分阶段部署?答:因为它改变了字节码格式,所有客户端(geth、reth、nethermind 等)都要同步升级,且要保证跨客户端共识一致。机制上分阶段:先启用 EOF 部署(EIP-3540),再启用新操作码(EIP-4200 RJUMP),再启用类型化栈(EIP-4750)。边界在于:每个阶段都要通过硬分叉激活,不能一步到位。延伸:这是以太坊协议升级的标准节奏。
- EOF 对 Solidity 开发者有什么影响?答:短期内透明(编译器自动处理);长期看可以写出更紧凑、更安全的合约(如多个代码段、相对跳转)。机制上 Solidity 编译器会按目标 EOF 版本生成字节码。边界在于:老合约(传统格式)不受影响,新合约可以选择是否用 EOF。延伸:生产合约短期内不用急着迁。
- EOF 与 EWASM 是什么关系?答:EWASM 是把 EVM 换成 WebAssembly 运行时的大重构,EOF 是在现有 EVM 基础上优化字节码格式;两者是不同方向。机制上 EOF 是渐进改进,EWASM 是激进重构。边界在于:EWASM 因为工程复杂度高被搁置,EOF 是当前主线。延伸:EVM 的演进以渐进 EIP 为主。
动手练习
练习 1:手写一个最小合约的字节码
- 任务:用操作码写一个极简合约(存一个值、读一个值),手工推导出它的 runtime code,对照 Solidity 编译输出。
- 验收标准:
- 能写出 PUSH1、SLOAD、SSTORE、STOP 的字节序列。
- 能说明每个操作码的 Gas 量级。
- 能解释为什么 Solidity 编译出的字节码比手写的复杂。
练习 2:推演一次 DELEGATECALL 调用
- 任务:用 OpenZeppelin ERC1967 代理的代码,推演一次用户调用代理的
transfer()时,address(this)、msg.sender、存储槽分别是什么。 - 验收标准:
- 画出调用链:EOA → Proxy → Impl。
- 标注每一步的上下文值。
- 说明升级 Impl 地址后,Proxy 的存储如何不变。
自检清单
- [ ] 能否画出 EVM 四区模型,并标注每区的生命周期与成本量级?
- [ ] 能否解释为什么 EVM 字长是 256 位,以及栈深 1024 的设计动机?
- [ ] 能否说明 JUMPDEST 扫描的机制,以及为什么不能跳进 PUSH 数据段?
- [ ] 能否对比四种调用指令的上下文差异?
- [ ] 能否推演 DELEGATECALL 的代理模式,并说明 msg.sender 为什么不变?
- [ ] 能否推导 CREATE2 的地址公式,并说明 clash 风险?
- [ ] 能否说明 block.timestamp 的操纵边界,以及为什么不能做强随机数?
- [ ] 能否简述 EOF 解决了传统字节码的什么问题?
延伸阅读
- Ethereum Yellow Paper:EVM 操作码定义、Gas 表、四区模型的权威来源(以最新版本为准)。
- EIP-1967:代理存储槽标准(implementation/admin 槽位)。
- EIP-3540:EOF 字节码格式。
- EIP-150:调用栈 Gas 调整(63/64 规则)。
- Solidity 官方文档:
Layout of State Variables in Storage、Mappings、Contract ABI。
待整理清单
- [ ] 补充 EOF 各阶段 EIP 的主网激活状态(待确认,以当前硬分叉为准)
- [ ] 补充具体操作码的 Gas 表(按当前硬分叉版本)
- [ ] 补充 EOF 与传统字节码的性能对比实测数据