区块链原理 / 系统课时
编写正反例与重放攻击回归测试
编写正反例与重放攻击回归测试
证明系统上线前不能只验证“正确证明能通过”。这一课把正常证明、伪造证明、公开输入篡改、整数越界和重复提交写成可重复执行的 Foundry 回归测试,并明确每类异常应该在 Verifier、业务合约还是 EVM 算术边界被拒绝。
学习目标
- 为有效证明和四类异常路径建立可自动运行的测试用例。
- 区分“证明无效”“公开输入业务不匹配”“nullifier 已消费”和 EVM 算术溢出的拒绝位置。
- 用固定断言验证失败原因,避免只写“应该 revert”的宽松测试。
先把五类场景映射到拒绝边界
不要把所有失败都断言成同一个 revert。测试矩阵先规定输入如何被破坏,以及应该由哪一层负责拒绝。
| 场景 | 变更方式 | 预期拒绝点 | 应断言的结果 |
|---|---|---|---|
| 正常证明 | proof 与 4 个 public signals 一致 | 不拒绝 | usedNullifiers[42] == true |
| 伪造证明 | proofHash 随机替换 | Verifier | InvalidProof() |
| 公开输入篡改 | proof 不变,仅把 amount 从 100 改为 101 |
Verifier | InvalidProof() |
| 整数越界 | 对 type(uint256).max 执行 + 1 |
Solidity 0.8.x 算术检查 | Panic(0x11) |
| 重放攻击 | 相同 nullifier 第二次提交 | 业务合约 | NullifierUsed() |
这里的“伪造见证”在链上测试中不会直接传入 witness:链上只看到 proof 和 public signals。若 witness 不满足电路约束,攻击者应无法得到能通过真实 Groth16 Verifier 的 proof,因此链上回归应把它表现为“无效证明被 Verifier 拒绝”。

建立可复现的最小合约
下面用一个确定性的 MockVerifier 代替真实 Groth16 验证器:它要求 proofHash == keccak256(abi.encode(signals))。这样可以稳定测试业务边界,但它不是密码学验证器;项目验收时应把接口替换为由可信 zkey 导出的真实 Verifier。
// test/ProofConsumer.t.sol
pragma solidity ^0.8.24;
import "forge-std/Test.sol";
interface IVerifier {
function verifyProof(bytes32 proofHash, uint256[4] calldata signals)
external
view
returns (bool);
}
contract MockVerifier is IVerifier {
function verifyProof(bytes32 proofHash, uint256[4] calldata signals)
external
pure
returns (bool)
{
return proofHash == keccak256(abi.encode(signals));
}
}
contract ProofConsumer {
error WrongScope();
error WrongRecipient();
error NullifierUsed();
error InvalidProof();
error SignalOutOfField();
uint256 constant SNARK_SCALAR_FIELD =
21888242871839275222246405745257275088548364400416034343698204186575808495617;
IVerifier public immutable verifier;
uint256 public immutable expectedScope;
mapping(uint256 => bool) public usedNullifiers;
constructor(IVerifier verifier_, uint256 expectedScope_) {
verifier = verifier_;
expectedScope = expectedScope_;
}
function submit(bytes32 proofHash, uint256[4] calldata signals) external {
for (uint256 i; i < signals.length; ++i) {
if (signals[i] >= SNARK_SCALAR_FIELD) revert SignalOutOfField();
}
if (signals[0] != expectedScope) revert WrongScope();
if (address(uint160(signals[1])) != msg.sender) revert WrongRecipient();
if (usedNullifiers[signals[2]]) revert NullifierUsed();
if (!verifier.verifyProof(proofHash, signals)) revert InvalidProof();
usedNullifiers[signals[2]] = true;
}
function checkedIncrement(uint256 value) external pure returns (uint256) {
return value + 1;
}
}这段配置把 public signals 固定为 [scope, recipient, nullifier, amount]。在真实项目里,顺序必须和电路及生成的 Solidity Verifier 完全一致;如果电路只有 3 个公开信号,就不能在合约侧自行多塞一个字段。
编写正例、篡改、越界与重放用例
测试时先构造一组有效 signals,再只修改一个维度。这样失败原因是单变量的,回归时更容易定位到底是 Verifier、业务绑定还是状态消费出了问题。
contract ProofConsumerTest is Test {
MockVerifier verifier;
ProofConsumer consumer;
address alice;
uint256 constant SCOPE = 20261016;
function setUp() public {
verifier = new MockVerifier();
consumer = new ProofConsumer(verifier, SCOPE);
alice = makeAddr("alice");
}
function validSignals() internal view returns (uint256[4] memory s) {
s[0] = SCOPE;
s[1] = uint256(uint160(alice));
s[2] = 42;
s[3] = 100;
}
function proofFor(uint256[4] memory s) internal pure returns (bytes32) {
return keccak256(abi.encode(s));
}
function test_validProof_isAccepted() public {
uint256[4] memory s = validSignals();
vm.prank(alice);
consumer.submit(proofFor(s), s);
assertTrue(consumer.usedNullifiers(42));
}
function test_forgedProof_isRejected() public {
uint256[4] memory s = validSignals();
bytes32 forged = keccak256(bytes("forged-proof"));
vm.expectRevert(ProofConsumer.InvalidProof.selector);
vm.prank(alice);
consumer.submit(forged, s);
}
function test_tamperedPublicInput_isRejected() public {
uint256[4] memory original = validSignals();
bytes32 proof = proofFor(original);
uint256[4] memory tampered = original;
tampered[3] = 101;
vm.expectRevert(ProofConsumer.InvalidProof.selector);
vm.prank(alice);
consumer.submit(proof, tampered);
}
function test_uintOverflow_isRejected() public {
vm.expectRevert(bytes4(0x4e487b71)); // Panic(uint256)
consumer.checkedIncrement(type(uint256).max);
}
function test_replay_isRejected() public {
uint256[4] memory s = validSignals();
bytes32 proof = proofFor(s);
vm.prank(alice);
consumer.submit(proof, s);
vm.expectRevert(ProofConsumer.NullifierUsed.selector);
vm.prank(alice);
consumer.submit(proof, s);
}
}运行测试:
forge test --match-contract ProofConsumerTest -vv预期输出的关键结果如下;耗时等动态值会因机器而不同:
Ran 5 tests for test/ProofConsumer.t.sol:ProofConsumerTest
[PASS] test_forgedProof_isRejected()
[PASS] test_replay_isRejected()
[PASS] test_tamperedPublicInput_isRejected()
[PASS] test_uintOverflow_isRejected()
[PASS] test_validProof_isAccepted()
Suite result: ok. 5 passed; 0 failed; 0 skipped把测试升级为真实项目验收
Mock 只能验证控制流,不能替代密码学验收。接入真实 Groth16 Verifier 后,至少保留三项额外检查:第一,用真实电路生成一份有效 proof 并确认链上通过;第二,保持 proof 不变修改任一 public signal,确认验证失败;第三,使用不满足电路约束的 witness 生成证明时,确认工具链在 witness 或证明阶段失败,或最终 proof 无法通过 Verifier。
验收时还要观察状态副作用:无效 proof、篡改输入和重放失败后,不应产生新的 nullifier 消费记录;只有第一次成功验证后,usedNullifiers[42] 才应保持为 true。验证成功后再写入 nullifier,可以避免攻击者用无效证明提前“烧掉”尚未消费的标识。