reentrancy-patterns

Reentrancy Patterns

Single-Function Reentrancy

The classic variant. An external call re-enters the same function before state is updated.

// VULNERABLE: state update after external call
contract VulnerableVault {
    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) external {
        require(balances[msg.sender] >= amount);

        (bool success,) = msg.sender.call{value: amount}(""); // ← re-entry point
        require(success);

        balances[msg.sender] -= amount; // ← too late, attacker already re-entered
    }
}

// FIXED: checks-effects-interactions
contract FixedVault {
    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) external {
        if (balances[msg.sender] < amount) revert InsufficientBalance();

        balances[msg.sender] -= amount; // effect BEFORE interaction

        (bool success,) = msg.sender.call{value: amount}("");
        if (!success) revert TransferFailed();
    }
}

Cross-Function Reentrancy

Attacker re-enters a different function that reads stale state.

// VULNERABLE: withdraw and transfer share state
contract Vulnerable {
    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) external {
        require(balances[msg.sender] >= amount);
        (bool success,) = msg.sender.call{value: amount}(""); // ← attacker calls transfer() here
        require(success);
        balances[msg.sender] -= amount;
    }

    function transfer(address to, uint256 amount) external {
        require(balances[msg.sender] >= amount);
        balances[msg.sender] -= amount; // uses stale balance
        balances[to] += amount;
    }
}

Defense: ReentrancyGuard on all functions sharing state, plus CEI ordering.

Cross-Contract Reentrancy

Attacker re-enters a different contract that reads stale state from the first.

// Contract A: Lending pool that updates user balance
// Contract B: Reads user balance from A for collateral check
// Attack: Borrow from A → callback during withdrawal → B reads stale (higher) balance → over-borrow

// Defense: ReentrancyGuard + cross-contract state synchronization
// OR: use a protocol-wide reentrancy lock