智能合约与以太坊 / 系统课时

用 nonce 阻断签名重放

用 nonce 阻断签名重放

离线签名授权允许用户先签署消息,再由其他账户提交链上交易。但如果合约不记录授权是否已使用,同一份签名就可能被重复执行。本课使用 Solidity 实现一次性授权,通过 nonce 消费机制阻止重放,并编写测试证明旧签名无法再次生效。

学习目标

  • 理解签名重放的成因,以及 nonce、签名者和授权内容之间的关系。
  • 使用 Solidity 实现包含 nonce 和有效期的一次性离线授权。
  • 编写成功执行、重复提交和错误 nonce 测试,验证防重放机制。

为什么有效签名仍然可能不安全

ECDSA 签名能够证明某个私钥持有者签署过指定消息,却不能自动证明这份消息尚未执行。

假设 Alice 授权 Bob 从合约中领取 100 个积分,Bob 提交签名后,合约完成积分发放。如果合约只检查签名是否来自 Alice,那么 Bob 再次提交相同签名时,验证结果仍然有效,可能再次获得 100 个积分。

签名本身没有自动失效机制。要让授权只能执行一次,合约必须维护链上状态。

常见防护字段如下:

字段 示例 作用
signer Alice 地址 确定授权主体
recipient Bob 地址 绑定授权接收者
amount 100 绑定授权数值
nonce 0 区分不同授权并防止重复执行
deadline 过期时间戳 限制授权有效期
chainId 31337 限制签名适用的链
verifyingContract 合约地址 限制签名适用的合约

其中,nonce 是 Number Used Once 的缩写,表示一次性使用的编号。合约通常为每个签名者维护独立计数器,初始值为 0;授权执行成功后,计数器增加 1。

例如,Alice 的当前 nonce 为 0,签名中也包含 0,合约允许执行。交易完成后链上 nonce 变为 1,同一份旧签名不再匹配当前授权编号。

设计签名验证与 nonce 消费流程

这里采用 EIP-712 结构化签名,把授权字段和合约域信息共同纳入签名摘要。示例使用 OpenZeppelin Contracts 5.x 的 EIP712、ECDSA 和 Nonces 实现。

离线授权签名验证与 nonce 消费流程

授权消费规则可以写成四个条件:

  1. 当前区块时间不得超过 deadline。
  2. 签名中的 nonce 必须等于 nonces(signer)。
  3. EIP-712 摘要恢复出的地址必须等于 signer,且不允许零地址。
  4. 验证通过后消费 nonce,再执行积分发放;任一步骤失败则整笔交易回滚。

使用按签名者递增的 nonce 有一个明确限制:同一签名者的授权需要按 nonce 顺序执行。例如 Alice 连续签署 nonce 为 0 和 1 的两份授权,如果 nonce 1 先提交,就会因为链上仍期待 nonce 0 而失败。

需要支持任意顺序执行时,可以改为随机 nonce 加已使用标记,或使用位图。对于按顺序消费的一次性授权,递增计数器更简单。

实现一次性授权合约

示例环境使用 Solidity 0.8.24、OpenZeppelin Contracts 5.x 和 Foundry。创建 Foundry 项目后,在项目根目录安装依赖:

bash
forge init nonce-demo
cd nonce-demo
forge install OpenZeppelin/openzeppelin-contracts@v5.0.2

预期结果:项目中存在 lib/openzeppelin-contracts 依赖目录,执行命令没有报错。若已有同名项目,直接在项目根目录安装依赖即可。

在 foundry.toml 中配置导入路径:

toml
[profile.default]
solc_version = "0.8.24"
remappings = ["@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/"]

创建 src/NonceVoucher.sol,实现完整的授权消费逻辑:

solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {Nonces} from "@openzeppelin/contracts/utils/Nonces.sol";

contract NonceVoucher is EIP712, Nonces {
    bytes32 private constant CLAIM_TYPEHASH = keccak256(
        "Claim(address signer,address recipient,uint256 amount,uint256 nonce,uint256 deadline)"
    );

    mapping(address => uint256) public credits;

    error Expired();
    error InvalidNonce();
    error InvalidSigner();

    constructor() EIP712("NonceVoucher", "1") {}

    function claim(
        address signer,
        address recipient,
        uint256 amount,
        uint256 nonce,
        uint256 deadline,
        bytes calldata signature
    ) external {
        require(block.timestamp <= deadline, Expired());
        require(nonce == nonces(signer), InvalidNonce());

        // 域分隔符绑定当前链和当前合约,避免跨域复用签名。
        bytes32 structHash = keccak256(
            abi.encode(
                CLAIM_TYPEHASH,
                signer,
                recipient,
                amount,
                nonce,
                deadline
            )
        );
        bytes32 digest = _hashTypedDataV4(structHash);
        address recovered = ECDSA.recover(digest, signature);
        require(signer != address(0) && recovered == signer, InvalidSigner());

        // 在更新业务余额前消费授权编号;失败交易会整体回滚。
        _useNonce(signer);
        credits[recipient] += amount;
    }
}

这里采用独立的 signer 参数,而不是把 msg.sender 当作授权者,因此用户可以签名后交给其他地址代为提交交易。

Nonces 提供 nonces(owner) 查询和内部 _useNonce(owner) 消费能力。因为执行前先检查 nonce,消费时取出的当前编号就是已验证的编号。

EIP712 的域包含名称、版本、链 ID 和合约地址。即使业务字段完全一致,切换到另一条链或另一份部署合约后,签名摘要通常也会变化。链分叉后如果链 ID 保持相同,域信息本身不能提供绝对的跨分叉保护。

该示例发放的是合约内部积分,不涉及 ERC-20 资金托管。真实资产授权还需要处理余额约束、转账失败和外部调用带来的重入风险。

编写已用签名的失败测试

测试必须使用真实私钥生成与合约一致的 EIP-712 摘要,再验证第一次授权成功、第二次提交失败,而不是随意填写一个伪造签名。

创建 test/NonceVoucher.t.sol:

solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Test} from "forge-std/Test.sol";
import {NonceVoucher} from "../src/NonceVoucher.sol";

contract NonceVoucherTest is Test {
    NonceVoucher voucher;
    uint256 constant ALICE_KEY = 0xA11CE;
    address alice;
    address bob = address(0xB0B);

    bytes32 constant CLAIM_TYPEHASH = keccak256(
        "Claim(address signer,address recipient,uint256 amount,uint256 nonce,uint256 deadline)"
    );

    function setUp() public {
        voucher = new NonceVoucher();
        alice = vm.addr(ALICE_KEY);
    }

    function signClaim(uint256 nonce) internal view returns (bytes32) {
        bytes32 structHash = keccak256(
            abi.encode(CLAIM_TYPEHASH, alice, bob, 100, nonce, 2000)
        );
        bytes32 domain = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256("NonceVoucher"),
                keccak256("1"),
                block.chainid,
                address(voucher)
            )
        );
        return keccak256(abi.encodePacked(hex"1901", domain, structHash));
    }

    function testReplayRejected() public {
        vm.warp(1000);
        bytes32 digest = signClaim(0);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ALICE_KEY, digest);
        bytes memory sig = abi.encodePacked(r, s, v);

        voucher.claim(alice, bob, 100, 0, 2000, sig);
        assertEq(voucher.credits(bob), 100);
        assertEq(voucher.nonces(alice), 1);

        // 相同签名再次提交必须回滚,不能重复获得积分。
        vm.expectRevert(NonceVoucher.InvalidNonce.selector);
        voucher.claim(alice, bob, 100, 0, 2000, sig);
        assertEq(voucher.credits(bob), 100);
    }

    function testFutureNonceRejected() public {
        vm.warp(1000);
        bytes32 digest = signClaim(1);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ALICE_KEY, digest);
        bytes memory sig = abi.encodePacked(r, s, v);

        vm.expectRevert(NonceVoucher.InvalidNonce.selector);
        voucher.claim(alice, bob, 100, 1, 2000, sig);
        assertEq(voucher.nonces(alice), 0);
    }
}

在项目根目录执行:

bash
forge test --match-contract NonceVoucherTest

预期结果:

text
[PASS] testFutureNonceRejected()
[PASS] testReplayRejected()
Suite result: ok. 2 passed; 0 failed; 0 skipped

输出中的耗时、Gas 和文件路径会随环境变化,因此这里只保留应当观察到的测试名称与通过状态。

第一个测试证明:授权成功执行后,Alice 的 nonce 变为 1,旧签名再次提交触发 InvalidNonce,Bob 的积分仍为 100。第二个测试证明:跳过当前 nonce 提交未来授权也会失败,且失败不会消耗 nonce。

审计 nonce 机制时检查哪些边界

nonce 检查通过不代表整个授权系统已经安全。审计时至少检查以下条件:

检查项 错误实现 正确结果
重复使用 成功后不更新 nonce 第二次提交必须回滚
不同签名者 所有用户共享一个 nonce 每个签名者独立维护
参数篡改 只签 nonce,不签 amount recipient、amount 等业务字段全部进入摘要
过期授权 不校验 deadline 超过 deadline 后拒绝执行
跨合约重放 使用不带合约域的原始消息哈希 签名绑定 verifyingContract
跨链重放 不绑定 chainId 使用适当的域信息区分链
消费原子性 先执行不可回滚的外部副作用 优先消费 nonce,再执行受控操作

还有一个容易遗漏的产品问题:Alice 签署 nonce 为 0 的授权,但暂时不想使用它。若合约只允许通过成功执行授权来增加 nonce,Alice 就不能主动撤销尚未提交的签名。

生产实现通常会额外提供授权者主动失效 nonce 的机制,例如允许签名者调用受权限限制的取消函数,将当前 nonce 增加 1。该操作也必须验证调用者身份,不能允许任意账户替别人推进 nonce。

最后可以增加一个篡改测试:使用 Alice 对 amount=100 签出的签名,尝试调用 claim 时传入 amount=200。因为签名摘要发生变化,恢复出的地址不再匹配 Alice,授权应当失败,积分与 nonce 均不改变。

nonce 防重放的验收标准应当是链上状态可验证:同一授权只能成功消费一次,失败不改变 nonce,不同签名者相互隔离,签名绑定完整业务字段及正确的 EIP-712 域。满足这些条件后,再结合授权撤销、过期控制和业务级权限检查,才能形成可用于真实场景的离线签名授权方案。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用 nonce 阻断签名重放

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通