032_重入攻击防御全解：从ReentrancyGuard到2025年高级防护模式，构建智能合约的安全边界

// 不安全：先进行外部调用，后更新状态
function withdraw(uint amount) public {
    require(balances[msg.sender] >= amount, "Insufficient balance");
    // 危险：在更新状态前进行外部调用
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
    // 状态更新太晚，可能被重入
    balances[msg.sender] -= amount;
}

// 安全：遵循Checks-Effects-Interactions模式
function withdraw(uint amount) public {
    // 1. Checks
    require(balances[msg.sender] >= amount, "Insufficient balance");
    
    // 2. Effects
    balances[msg.sender] -= amount;
    
    // 3. Interactions
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
}

// OpenZeppelin的ReentrancyGuard简化版实现
abstract contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    
    uint256 private _status;
    
    constructor() {
        _status = _NOT_ENTERED;
    }
    
    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }
}

// 在合约中使用ReentrancyGuard
contract SecureContract is ReentrancyGuard {
    // 在敏感函数上应用nonReentrant修饰符
    function withdraw(uint amount) public nonReentrant {
        // 函数逻辑
    }
}

mapping(address => bool) private _isWithdrawing;

modifier noConcurrentWithdraw() {
    require(!_isWithdrawing[msg.sender], "Concurrent withdrawal not allowed");
    _isWithdrawing[msg.sender] = true;
    _;
    _isWithdrawing[msg.sender] = false;
}

// 两步提款模式
mapping(address => uint) private _pendingWithdrawals;

function requestWithdrawal(uint amount) public {
    require(balances[msg.sender] >= amount, "Insufficient balance");
    balances[msg.sender] -= amount;
    _pendingWithdrawals[msg.sender] += amount;
    emit WithdrawalRequested(msg.sender, amount);
}

function executeWithdrawal() public {
    uint amount = _pendingWithdrawals[msg.sender];
    require(amount > 0, "No pending withdrawal");
    _pendingWithdrawals[msg.sender] = 0;
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
}

mapping(address => bool) private _trustedContracts;

modifier controlledReentrant() {
    // 非白名单合约禁止重入
    if (!_trustedContracts[msg.sender]) {
        require(_status != _ENTERED, "Not trusted");
        _status = _ENTERED;
    }
    _;
    if (!_trustedContracts[msg.sender]) {
        _status = _NOT_ENTERED;
    }
}

modifier contextAwareReentrant() {
    // 只在特定上下文中允许重入
    require(contextAllowsReentrancy(), "Reentrancy not allowed in this context");
    _;
}

modifier stateConsistent() {
    uint256 preStateHash = getStateHash();
    _;
    uint256 postStateHash = getStateHash();
    require(postStateHash == preStateHash || stateChangedLegitimately(), 
            "State inconsistency detected");
}

// 代理合约中的重入保护
function _fallback() internal {
    require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
    _status = _ENTERED;
    
    // 委托调用到实现合约
    (bool success, ) = _implementation.delegatecall(msg.data);
    
    _status = _NOT_ENTERED;
    
    // 处理返回数据
    bytes memory returndata = msg.data;
    assembly {
        switch success
        case 0 { revert(add(returndata, 32), mload(returndata)) }
        default { return(add(returndata, 32), mload(returndata)) }
    }
}

// 安全的外部调用包装器
function safeExternalCall(address target, bytes memory data) internal returns (bool, bytes memory) {
    require(_isAuthorized(target), "Unauthorized external call");
    
    // 保存状态快照
    uint256 stateSnapshot = _getStateSnapshot();
    
    // 执行外部调用
    (bool success, bytes memory returndata) = target.call{value: 0}(data);
    
    // 验证状态变化
    require(_validateStateChanges(stateSnapshot), "Invalid state changes detected");
    
    return (success, returndata);
}

// Certora验证语言中的重入安全规范
rule noReentrancy() {
    env e;
    address user;
    
    // 执行任何操作序列
    calldataarg args;
    contract.functions{f: *}(e, user, args);
    
    // 验证合约状态一致性
    assert totalAssets == sumOfUserBalances(), "Inconsistent asset balances";
}

// 重入攻击测试示例
describe("Reentrancy Protection", function() {
  it("should prevent reentrancy attacks", async function() {
    // 部署目标合约和攻击合约
    const Target = await ethers.getContractFactory("TargetContract");
    const target = await Target.deploy();
    await target.deployed();
    
    const Attacker = await ethers.getContractFactory("ReentrancyAttacker");
    const attacker = await Attacker.deploy(target.address);
    await attacker.deployed();
    
    // 设置初始状态
    await target.deposit({value: ethers.utils.parseEther("10")});
    await attacker.addFunds({value: ethers.utils.parseEther("1")});
    
    // 尝试攻击并验证防御是否有效
    const targetBalanceBefore = await ethers.provider.getBalance(target.address);
    
    // 应该回滚攻击交易
    await expect(attacker.attack()).to.be.reverted;
    
    // 验证余额没有异常变化
    const targetBalanceAfter = await ethers.provider.getBalance(target.address);
    expect(targetBalanceAfter).to.equal(targetBalanceBefore);
  });
});

// 简化的调用模式监控合约
contract CallMonitor {
    mapping(address => uint) public callCounts;
    mapping(address => uint) public lastCallTime;
    uint public threshold = 10;
    uint public timeWindow = 1 seconds;
    
    event SuspiciousActivity(address caller, uint count, uint timeWindow);
    
    modifier monitorCalls() {
        // 检查调用频率
        uint currentTime = block.timestamp;
        if (lastCallTime[msg.sender] > 0 && 
            currentTime - lastCallTime[msg.sender] < timeWindow) {
            callCounts[msg.sender]++;
            if (callCounts[msg.sender] > threshold) {
                emit SuspiciousActivity(msg.sender, callCounts[msg.sender], timeWindow);
                // 可选：执行防御操作，如暂停功能
            }
        } else {
            callCounts[msg.sender] = 1;
        }
        lastCallTime[msg.sender] = currentTime;
        
        _;
    }
}

// 简化的有漏洞代码
function withdrawDAO(uint amount) noEther internal returns (bool) {
    if (balances[msg.sender] >= amount) {
        // 危险：在更新状态前发送以太币
        if (msg.sender.call.value(amount)()) {
            // 太晚更新状态
            balances[msg.sender] -= amount;
            return true;
        }
    }
    return false;
}

// 修复后的代码
function withdrawDAO(uint amount) noEther internal returns (bool) {
    // Checks
    if (balances[msg.sender] < amount) {
        return false;
    }
    
    // Effects
    balances[msg.sender] -= amount;
    
    // Interactions
    if (msg.sender.call.value(amount)()) {
        return true;
    } else {
        // 失败情况下恢复状态
        balances[msg.sender] += amount;
        return false;
    }
}

// 推荐的安全开发模式
contract SecureContract {
    // 使用OpenZeppelin的安全组件
    using SafeERC20 for IERC20;
    
    // 应用重入防护
    uint private _status;
    modifier nonReentrant() {
        require(_status == 0, "Reentrant call");
        _status = 1;
        _;
        _status = 0;
    }
    
    // 安全的提款函数
    function withdraw(uint amount) external nonReentrant {
        // Checks
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        // Effects
        balances[msg.sender] -= amount;
        totalBalance -= amount;
        
        // Interactions
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
        
        emit Withdrawal(msg.sender, amount);
    }
}