Smart contract security and auditing — reentrancy, overflow, access control with vulnerable code demos

// VULNERABLE — sends ETH before updating state
contract VulnerableVault {
    mapping(address => uint256) public balances;

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw() public {
        uint256 bal = balances[msg.sender];
        require(bal > 0);
        (bool ok, ) = msg.sender.call{value: bal}("");
        require(ok);
        balances[msg.sender] = 0; // TOO LATE — attacker re-entered
    }
}

// ATTACKER — re-enters withdraw() via receive()
contract Attacker {
    VulnerableVault vault;
    constructor(address v) { vault = VulnerableVault(v); }

    function attack() external payable {
        vault.deposit{value: 1 ether}();
        vault.withdraw();
    }

    receive() external payable {
        if (address(vault).balance >= 1 ether) {
            vault.withdraw(); // balance still shows 1 ETH!
        }
    }
}

// FIXED — Checks-Effects-Interactions + reentrancy lock
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract SafeVault is ReentrancyGuard {
    mapping(address => uint256) public balances;

    function withdraw() public nonReentrant {
        uint256 bal = balances[msg.sender];
        require(bal > 0);
        balances[msg.sender] = 0;  // state BEFORE call
        (bool ok, ) = msg.sender.call{value: bal}("");
        require(ok);
    }
}

Always combine both defenses: update state before external calls (Checks-Effects-Interactions) AND use OpenZeppelin's ReentrancyGuard.

// VULNERABLE: uses DEX spot price (manipulable with flash loans)
contract VulnerableLending {
    IUniswapPair pair;

    function getPrice() public view returns (uint256) {
        (uint112 r0, uint112 r1, ) = pair.getReserves();
        return (uint256(r1) * 1e18) / uint256(r0); // spot price!
    }

    function borrow(uint256 collateral) public {
        uint256 price = getPrice(); // attacker inflated this
        uint256 limit = collateral * price / 1e18;
        // Attacker borrows max, price reverts, protocol drained
    }
}

// SAFE: Chainlink oracle with staleness check
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract SafeLending {
    AggregatorV3Interface immutable priceFeed;
    uint256 constant STALENESS = 3600; // 1 hour max

    constructor(address feed) {
        priceFeed = AggregatorV3Interface(feed);
    }

    function getPrice() public view returns (uint256) {
        (, int256 price, , uint256 updatedAt, ) = priceFeed.latestRoundData();
        require(price > 0, "Invalid price");
        require(block.timestamp - updatedAt < STALENESS, "Stale price");
        return uint256(price);
    }
}

Never use DEX spot prices as oracles. Use Chainlink, Uniswap TWAP, or other manipulation-resistant feeds.

// VULNERABLE: anyone can mint unlimited tokens
contract VulnerableToken {
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    function mint(address to, uint256 amount) public {
        // BUG: no access control! Anyone can call this
        balanceOf[to] += amount;
        totalSupply += amount;
    }
}

// FIXED: proper role-based access control
import "@openzeppelin/contracts/access/AccessControl.sol";

contract SafeToken is AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
    }

    function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
        balanceOf[to] += amount;
        totalSupply += amount;
    }
}

In 2022, a cross-chain bridge lost $325M because a key verification function was accidentally left public. Always audit every external/public function for proper access control.

# Install Slither
pip3 install slither-analyzer

# Run on your project
cd my-token
slither .

# Output shows:
# - Reentrancy vulnerabilities
# - Unused return values
# - Missing zero-address checks
# - Dangerous delegatecall usage
# - Low-level calls without checks
# Color-coded by severity: red (high), yellow (medium), green (info)