乐闻世界logo
搜索文章和话题

Solidity 中如何防止常见的智能合约安全漏洞？

3月6日 21:47

智能合约安全是区块链开发的核心议题。由于合约一旦部署就难以修改，且涉及资产安全，预防漏洞比修复漏洞更重要。以下是常见安全漏洞及防护措施。

1. 重入攻击（Reentrancy Attack）

漏洞原理

攻击者利用合约在状态更新前调用外部合约的特性，递归调用目标合约。

solidity
// 存在漏洞的合约
contract VulnerableBank {
    mapping(address => uint256) public balances;
    
    function withdraw() public {
        uint256 amount = balances[msg.sender];
        require(amount > 0);
        
        // 危险：先转账，后更新状态
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
        
        balances[msg.sender] = 0; // 更新太晚！
    }
}

// 攻击合约
contract Attacker {
    VulnerableBank public bank;
    
    constructor(address _bank) {
        bank = VulnerableBank(_bank);
    }
    
    receive() external payable {
        if (address(bank).balance >= 1 ether) {
            bank.withdraw(); // 递归调用
        }
    }
    
    function attack() external payable {
        bank.deposit{value: 1 ether}();
        bank.withdraw();
    }
}

防护措施

solidity
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SecureBank is ReentrancyGuard {
    mapping(address => uint256) public balances;
    bool private locked; // 互斥锁
    
    // 方案 1：Checks-Effects-Interactions 模式
    function withdraw() public {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "Insufficient balance"); // Checks
        
        balances[msg.sender] = 0; // Effects：先更新状态
        
        (bool success, ) = msg.sender.call{value: amount}(""); // Interactions
        require(success, "Transfer failed");
    }
    
    // 方案 2：使用 ReentrancyGuard
    function withdrawWithGuard() public nonReentrant {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "Insufficient balance");
        
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
        
        balances[msg.sender] = 0;
    }
    
    // 方案 3：自定义互斥锁
    modifier noReentrant() {
        require(!locked, "Reentrant call");
        locked = true;
        _;
        locked = false;
    }
}

2. 整数溢出/下溢（Integer Overflow/Underflow）

漏洞原理

Solidity 0.8.0 之前，整数运算溢出不会报错，导致意外结果。

solidity
// Solidity < 0.8.0 的漏洞
contract VulnerableOverflow {
    uint8 public counter = 255;
    
    function increment() public {
        counter++; // 溢出为 0！
    }
    
    function decrement() public {
        counter--; // 下溢为 255！
    }
}

防护措施

solidity
// 方案 1：使用 Solidity 0.8.0+
contract SafeInSolidity08 {
    uint8 public counter = 255;
    
    function increment() public {
        counter++; // 自动检查溢出，溢出会 revert
    }
}

// 方案 2：使用 SafeMath 库（Solidity < 0.8.0）
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "Addition overflow");
        return c;
    }
    
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "Subtraction underflow");
        return a - b;
    }
    
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "Multiplication overflow");
        return c;
    }
}

// 方案 3：使用 unchecked 进行显式控制
contract ExplicitControl {
    function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            uint256 c = a + b;
            require(c >= a, "Overflow");
            return c;
        }
    }
}

3. 访问控制漏洞

漏洞原理

不正确的权限检查导致未授权访问。

solidity
// 存在漏洞的合约
contract VulnerableAccess {
    address public owner;
    
    function init() public {
        // 危险：任何人都可以调用
        owner = msg.sender;
    }
    
    function withdraw() public {
        // 危险：使用 tx.origin
        require(tx.origin == owner, "Not owner");
        payable(msg.sender).transfer(address(this).balance);
    }
}

防护措施

solidity
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

// 方案 1：使用 OpenZeppelin Ownable
contract SecureWithOwnable is Ownable {
    constructor() {
        // owner 在构造函数中设置
    }
    
    function secureWithdraw() public onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
}

// 方案 2：使用 AccessControl
contract SecureWithRoles is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    
    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, msg.sender);
    }
    
    function adminFunction() public onlyRole(ADMIN_ROLE) {
        // 只有管理员可以执行
    }
}

// 方案 3：正确的构造函数初始化
contract ProperInitialization {
    address public owner;
    bool private initialized;
    
    constructor() {
        owner = msg.sender;
        initialized = true;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner"); // 使用 msg.sender
        _;
    }
    
    modifier notInitialized() {
        require(!initialized, "Already initialized");
        _;
    }
}

4. 前端运行攻击（Front-Running）

漏洞原理

攻击者观察内存池中的交易，以更高的 Gas 价格抢先执行。

solidity
// 存在漏洞的合约
contract VulnerableFrontRunning {
    mapping(bytes32 => uint256) public bids;
    
    function placeBid(bytes32 itemId, uint256 amount) external {
        // 攻击者可以看到内存池中的出价，然后出更高价
        require(amount > bids[itemId], "Bid too low");
        bids[itemId] = amount;
    }
}

防护措施

solidity
contract SecureAgainstFrontRunning {
    struct Bid {
        bytes32 blindedBid;
        uint256 deposit;
    }
    
    mapping(address => Bid[]) public bids;
    mapping(bytes32 => address) public highestBidder;
    uint256 public highestBid;
    
    // 阶段 1：提交盲拍（哈希）
    function bid(bytes32 _blindedBid) external payable {
        bids[msg.sender].push(Bid({
            blindedBid: _blindedBid,
            deposit: msg.value
        }));
    }
    
    // 阶段 2：揭示真实出价
    function reveal(
        uint256[] calldata _values,
        bool[] calldata _fake,
        bytes32[] calldata _secret
    ) external {
        // 验证揭示的出价与提交的哈希匹配
        // ...
    }
    
    // 使用 Commit-Reveal 模式
    // 或使用密封拍卖
}

// 另一种方案：使用提交-揭示模式
contract CommitRevealAuction {
    struct Commit {
        bytes32 commitHash;
        uint256 deposit;
        bool revealed;
    }
    
    mapping(address => Commit) public commits;
    uint256 public revealDeadline;
    
    function commitBid(bytes32 _commitHash) external payable {
        require(block.timestamp < revealDeadline, "Commit period ended");
        commits[msg.sender] = Commit({
            commitHash: _commitHash,
            deposit: msg.value,
            revealed: false
        });
    }
    
    function revealBid(uint256 _bid, bytes32 _secret) external {
        require(block.timestamp >= revealDeadline, "Reveal not started");
        Commit storage c = commits[msg.sender];
        require(!c.revealed, "Already revealed");
        
        bytes32 hash = keccak256(abi.encodePacked(_bid, _secret));
        require(hash == c.commitHash, "Invalid reveal");
        
        c.revealed = true;
        // 处理出价...
    }
}

5. 时间操纵攻击

漏洞原理

矿工可以操纵区块时间戳（在一定范围内）。

solidity
// 存在漏洞的合约
contract VulnerableTime {
    uint256 public gameEndTime;
    
    constructor() {
        gameEndTime = block.timestamp + 1 days;
    }
    
    function claimPrize() external {
        // 矿工可以将时间戳设置得比实际时间早
        require(block.timestamp > gameEndTime, "Game not ended");
        // 发放奖品...
    }
}

防护措施

solidity
contract SecureTime {
    uint256 public gameStartBlock;
    uint256 public constant GAME_DURATION_BLOCKS = 7200; // 约 1 天
    
    constructor() {
        gameStartBlock = block.number;
    }
    
    // 使用区块号代替时间戳
    function claimPrize() external {
        require(
            block.number >= gameStartBlock + GAME_DURATION_BLOCKS,
            "Game not ended"
        );
        // 发放奖品...
    }
    
    // 如果需要使用时间戳，添加缓冲
    function claimPrizeWithBuffer() external {
        // 添加 15 分钟缓冲（约 90 个区块）
        require(
            block.timestamp >= gameEndTime + 15 minutes,
            "Game not ended with buffer"
        );
    }
}

6. 拒绝服务攻击（DoS）

漏洞原理

通过耗尽 Gas 或阻止关键功能执行来攻击合约。

solidity
// 存在漏洞的合约
contract VulnerableDoS {
    address[] public investors;
    mapping(address => uint256) public balances;
    
    // 危险：遍历可能耗尽 Gas
    function distributeDividends() external {
        for (uint i = 0; i < investors.length; i++) {
            // 如果 investors 数组很大，会耗尽 Gas
            payable(investors[i]).transfer(balances[investors[i]]);
        }
    }
}

// 另一种 DoS：通过 revert 阻止转账
contract VulnerableDoS2 {
    mapping(address => uint256) public balances;
    
    function withdraw() external {
        uint256 amount = balances[msg.sender];
        // 如果接收者是恶意合约，会 revert 阻止所有人提款
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
        balances[msg.sender] = 0;
    }
}

防护措施

solidity
contract SecureAgainstDoS {
    mapping(address => uint256) public balances;
    mapping(address => bool) public withdrawn;
    
    // 方案 1：拉取模式（Pull）代替推送模式（Push）
    function withdraw() external {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance");
        require(!withdrawn[msg.sender], "Already withdrawn");
        
        withdrawn[msg.sender] = true;
        balances[msg.sender] = 0;
        
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
    
    // 方案 2：分页处理
    function distributeDividends(uint256 _start, uint256 _end) external {
        require(_end <= investors.length, "Invalid range");
        require(_end - _start <= 100, "Batch too large"); // 限制批次大小
        
        for (uint i = _start; i < _end; i++) {
            address investor = investors[i];
            if (!paid[investor]) {
                paid[investor] = true;
                payable(investor).transfer(balances[investor]);
            }
        }
    }
    
    // 方案 3：使用 try-catch（Solidity 0.6.0+）
    function safeTransfer(address _to, uint256 _amount) internal {
        (bool success, ) = _to.call{value: _amount}("");
        if (!success) {
            // 记录失败，不阻止其他转账
            failedTransfers[_to] += _amount;
        }
    }
}

7. 随机数漏洞

已在随机数专题中详细讲解，核心要点：

  • 不要使用区块哈希、时间戳等链上数据生成随机数
  • 使用 Chainlink VRF 等预言机方案
  • 使用 Commit-Reveal 模式

8. 逻辑漏洞

权限绕过

solidity
// 危险：逻辑错误导致权限绕过
contract LogicError {
    mapping(address => bool) public admins;
    
    function addAdmin(address _admin) external {
        // 错误：缺少权限检查
        admins[_admin] = true;
    }
}

// 修复
contract FixedLogic {
    mapping(address => bool) public admins;
    
    modifier onlyAdmin() {
        require(admins[msg.sender], "Not admin");
        _;
    }
    
    function addAdmin(address _admin) external onlyAdmin {
        admins[_admin] = true;
    }
}

重入变种：跨函数重入

solidity
contract CrossFunctionReentrancy {
    mapping(address => uint256) public balances;
    
    function transfer(address _to, uint256 _amount) external {
        require(balances[msg.sender] >= _amount);
        balances[msg.sender] -= _amount;
        balances[_to] += _amount;
    }
    
    function withdraw() external {
        uint256 amount = balances[msg.sender];
        require(amount > 0);
        
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
        
        // 攻击者可以在 receive 中调用 transfer，然后再次 withdraw
        balances[msg.sender] = 0;
    }
}

// 修复：使用互斥锁
contract FixedCrossFunction is ReentrancyGuard {
    function withdraw() external nonReentrant {
        // ...
    }
}

9. 安全开发最佳实践

solidity
// 完整的安全合约模板
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";

contract SecureContractTemplate is ReentrancyGuard, Pausable, Ownable {
    using Address for address;
    
    // 1. 使用最新编译器版本
    pragma solidity ^0.8.19;
    
    // 2. 使用内置溢出检查（0.8.0+）
    uint256 public counter;
    
    // 3. 使用 ReentrancyGuard
    function withdraw() external nonReentrant whenNotPaused {
        // ...
    }
    
    // 4. 使用 Pausable 应急暂停
    function pause() external onlyOwner {
        _pause();
    }
    
    // 5. 正确的访问控制
    function adminFunction() external onlyOwner {
        // ...
    }
    
    // 6. 事件记录
    event ActionExecuted(address indexed user, uint256 amount);
    
    // 7. 自定义错误（Gas 优化）
    error InsufficientBalance(uint256 requested, uint256 available);
    error InvalidAddress();
    
    // 8. 输入验证
    function validateInput(address _addr, uint256 _amount) internal pure {
        if (_addr == address(0)) revert InvalidAddress();
        if (_amount == 0) revert InsufficientBalance(_amount, 0);
    }
    
    // 9. 使用 Checks-Effects-Interactions 模式
    function secureTransfer(address _to, uint256 _amount) external {
        // Checks
        require(balances[msg.sender] >= _amount, "Insufficient balance");
        
        // Effects
        balances[msg.sender] -= _amount;
        
        // Interactions
        (bool success, ) = _to.call{value: _amount}("");
        require(success, "Transfer failed");
    }
    
    // 10. 接收 ETH 的安全处理
    receive() external payable {
        emit DepositReceived(msg.sender, msg.value);
    }
}

10. 安全审计检查清单

  • 重入攻击防护（Checks-Effects-Interactions、ReentrancyGuard）
  • 整数溢出检查（使用 0.8.0+ 或 SafeMath）
  • 访问控制验证（Ownable、AccessControl）
  • 输入验证（零地址检查、范围检查）
  • 时间操纵防护（使用区块号代替时间戳）
  • 随机数安全（使用 VRF）
  • DoS 防护（拉取模式、分页处理）
  • 事件完整性（所有状态变更触发事件）
  • 应急机制（Pausable、升级能力）
  • 代码审计（Slither、Mythril、Certora）

11. 安全工具

  1. 静态分析：Slither、Mythril、Manticore
  2. 形式化验证：Certora、K Framework
  3. 模糊测试：Echidna、Harvey
  4. 监控：Tenderly、Forta
javascript
// hardhat 配置安全工具
require("@nomiclabs/hardhat-truffle5");
require("hardhat-gas-reporter");
require("solidity-coverage");

module.exports = {
  solidity: {
    version: "0.8.19",
    settings: {
      optimizer: { enabled: true, runs: 200 }
    }
  },
  gasReporter: { enabled: true },
};

​

标签：Solidity
热门标签
更多
Git(114)C语言(23)C++(15)React(34)前端(148)Cypress(30)JavaScript(56)Linux(20)Docker(65)Rust(10)TypeScript(27)Mongoose(18)MySQL(8)Vue(13)Tailwind CSS(29)CSS(19)ElasticSearch(24)网络(12)TypeORM(31)