The Most Common Smart Contract Vulnerabilities of 2025: Fix Them in 2 Hours

// VULNERABLE CODE - I found this exact pattern in 12 contracts
contract VulnerableVault {
    mapping(address => uint256) public balances;
    
    function withdraw(uint256 amount) external {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        // DANGER: External call before state update
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
        
        // Attacker re-enters here before this executes
        balances[msg.sender] -= amount;
    }
}

// SECURE VERSION - Uses Checks-Effects-Interactions pattern
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SecureVault is ReentrancyGuard {
    mapping(address => uint256) public balances;
    
    function withdraw(uint256 amount) external nonReentrant {
        // Checks
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        // Effects - Update state BEFORE external calls
        balances[msg.sender] -= amount;
        
        // Interactions - External call last
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// VULNERABLE - I found this in a high-TVL protocol
contract UnsafeRewards {
    mapping(address => uint256) public rewards;
    
    function calculateReward(uint256 baseReward, uint256 multiplier) public pure returns (uint256) {
        unchecked {
            // Gas optimization that costs millions
            return baseReward * multiplier; // Can overflow!
        }
    }
    
    function claimRewards() external {
        uint256 reward = calculateReward(userStake[msg.sender], 1000);
        unchecked {
            rewards[msg.sender] -= reward; // Can underflow to max uint256!
        }
    }
}

// SECURE - Only use unchecked when mathematically impossible to overflow
contract SafeRewards {
    mapping(address => uint256) public rewards;
    
    function calculateReward(uint256 baseReward, uint256 multiplier) public pure returns (uint256) {
        // Let Solidity 0.8+ handle overflow checks
        uint256 reward = baseReward * multiplier;
        require(reward >= baseReward, "Overflow protection"); // Extra safety
        return reward;
    }
    
    function claimRewards() external {
        uint256 reward = calculateReward(userStake[msg.sender], 1000);
        // State update with built-in underflow protection
        rewards[msg.sender] -= reward;
    }
}

// VULNERABLE - Found this in a contract with $500K TVL
contract UnsafeProtocol {
    address public admin;
    bool public paused;
    
    // Missing access control!
    function setAdmin(address newAdmin) external {
        admin = newAdmin; // Anyone can become admin
    }
    
    function pause() external {
        paused = true; // Anyone can pause the protocol
    }
    
    function emergencyWithdraw() external {
        payable(admin).transfer(address(this).balance); // Only checks admin, doesn't restrict caller
    }
}

// SECURE VERSION
import "@openzeppelin/contracts/access/Ownable.sol";

contract SecureProtocol is Ownable {
    bool public paused;
    
    // Only owner can call this
    function setAdmin(address newAdmin) external onlyOwner {
        transferOwnership(newAdmin);
    }
    
    // Explicit access control
    function pause() external onlyOwner {
        paused = true;
    }
    
    // Two-step verification
    function emergencyWithdraw() external onlyOwner {
        require(paused, "Must pause first");
        payable(owner()).transfer(address(this).balance);
    }
}

// VULNERABLE TO FRONT-RUNNING
contract NaiveSwap {
    function swap(uint256 amountIn, uint256 minAmountOut) external {
        uint256 amountOut = calculateSwap(amountIn);
        require(amountOut >= minAmountOut, "Slippage too high");
        // Bot sees this in mempool and front-runs with higher gas
        token.transfer(msg.sender, amountOut);
    }
}

// MEV-RESISTANT VERSION
contract SecureSwap {
    mapping(bytes32 => bool) public usedCommitments;
    
    // Step 1: Commit to trade without revealing details
    function commitToSwap(bytes32 commitment) external {
        require(!usedCommitments[commitment], "Already used");
        usedCommitments[commitment] = true;
        emit SwapCommitted(msg.sender, commitment);
    }
    
    // Step 2: Execute after commitment is mined
    function executeSwap(
        uint256 amountIn, 
        uint256 minAmountOut,
        bytes32 salt
    ) external {
        // Verify commitment matches
        bytes32 commitment = keccak256(abi.encodePacked(
            msg.sender, amountIn, minAmountOut, salt
        ));
        require(usedCommitments[commitment], "No commitment");
        
        uint256 amountOut = calculateSwap(amountIn);
        require(amountOut >= minAmountOut, "Slippage too high");
        
        token.transfer(msg.sender, amountOut);
        delete usedCommitments[commitment];
    }
}

// EXPLOITABLE BY MINERS
contract VulnerableLottery {
    function drawWinner() external {
        // Miner can manipulate this!
        uint256 randomness = uint256(keccak256(abi.encodePacked(
            block.timestamp,
            block.difficulty
        )));
        
        address winner = participants[randomness % participants.length];
        winner.transfer(prize);
    }
}

// SECURE RANDOMNESS
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";

contract SecureLottery is VRFConsumerBase {
    bytes32 internal keyHash;
    uint256 internal fee;
    
    function requestRandomWinner() external returns (bytes32 requestId) {
        require(LINK.balanceOf(address(this)) >= fee, "Not enough LINK");
        return requestRandomness(keyHash, fee);
    }
    
    // Callback from Chainlink VRF
    function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
        address winner = participants[randomness % participants.length];
        winner.transfer(prize);
    }
}

// My actual test that catches reentrancy
function testReentrancyProtection() public {
    Attacker attacker = new Attacker(vault);
    vm.deal(address(attacker), 1 ether);
    
    // This should fail with "ReentrancyGuard: reentrant call"
    vm.expectRevert();
    attacker.attack();
}

# Install security tools
forge install foundry-rs/forge-std
cargo install slither-analyzer

# Run automated security scan
slither . --detect reentrancy-eth,unchecked-transfer
forge test --fuzz-runs 10000

Before deployment:
☐ Run Slither with zero high-severity findings
☐ Fuzz test with 10,000+ runs
☐ Manual review of every external call
☐ Verify access control on admin functions
☐ Test with actual exploit contracts
☐ Gas optimization AFTER security, never before