Advanced Security Documentation

Reentrancy Attacks

Reentrancy remains one of the most devastating attack vectors in Web3. It occurs when an external contract call allows an attacker to reenter the calling contract before the first execution completes, potentially draining funds through recursive calls.

The 2016 DAO hack that lost $60M used this technique, and variants continue to appear in modern exploits. The key vulnerability occurs when state changes happen after external calls rather than before.

// VULNERABLE CODE - DO NOT USE
function withdraw(uint256 amount) external {
    require(balances[msg.sender] >= amount, "Insufficient balance");
    
    // Dangerous external call before state update
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
    
    // State update happens after external call
    balances[msg.sender] -= amount;
}

// SECURE IMPLEMENTATION
function withdrawSecure(uint256 amount) external {
    require(balances[msg.sender] >= amount, "Insufficient balance");
    
    // Update state before external call
    balances[msg.sender] -= amount;
    
    // External call happens after state update
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
}
  

// Always follow the Checks-Effects-Interactions pattern: validate conditions, update state, then make external calls

Flash Loan Attacks & Price Manipulation

Flash loans enable attackers to borrow massive amounts of assets without collateral for a single transaction. This capital can then be used to:

• Manipulate on-chain price oracles
• Execute governance attacks through temporary token accumulation
• Drain poorly secured lending protocols through price oracle manipulation
• Arbitrage across multiple DEXs with extreme leverage

Flash loan attacks have resulted in over $1B in losses across DeFi. Protocols like Cream Finance, Beanstalk, and Harvest Finance have all suffered multimillion-dollar exploits through this vector.

// Flash loan attack prevention pattern
contract FlashLoanGuard {
    // Reentrancy lock
    uint256 private _status;
    
    // Transaction-scope variables to detect price manipulation
    uint256 private _initialBalance;
    uint256 private _initialPrice;
    
    modifier nonReentrant() {
        require(_status != 2, "ReentrancyGuard: reentrant call");
        _status = 2;
        _;
        _status = 1;
    }
    
    modifier flashLoanGuard() {
        // Store state before function execution
        _initialBalance = address(this).balance;
        _initialPrice = getOraclePrice();
        _;
        // Verify no manipulation occurred
        require(
            _validateStateConsistency(_initialBalance, _initialPrice),
            "Potential flash loan attack"
        );
    }
    
    function _validateStateConsistency(
        uint256 initialBalance, 
        uint256 initialPrice
    ) internal view returns (bool) {
        // Custom validation logic
        // Compare current state with initial state
        return true; // Implementation depends on specific protocol
    }
    
    function getOraclePrice() internal view returns (uint256) {
        // Implementation for getting price
        return 0;
    }
    
    // Apply both guards to sensitive functions
    function executeTrade(uint256 amount) external nonReentrant flashLoanGuard {
        // Implementation
    }
}
  

// Implement transaction-scoped checks that validate state consistency before and after critical operations

Access Control Failures

Inadequate access control is a frequent vulnerability in Web3 protocols. This includes:

• Missing authentication checks on critical functions
• Incorrect signature validation allowing signature replay
• Overprivileged roles with excessive system control
• Privileged function frontrunning during ownership transfers

The Wormhole bridge exploit ($320M) and Ronin bridge hack ($600M) both stemmed from access control failures.

// Access control pattern using modifiers
contract SecureProtocol {
    address public admin;
    mapping(address => bool) public operators;
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "ADMIN_ONLY");
        _;
    }
    
    modifier onlyOperator() {
        require(operators[msg.sender], "OPERATOR_ONLY");
        _;
    }
    
    function setOperator(address operator, bool status) external onlyAdmin {
        operators[operator] = status;
    }
    
    function emergencyPause() external onlyOperator {
        // Implementation
    }
}
  

// Implement strict role-based access control with clearly defined permissions