存取控制失守：到底誰能呼叫這個函式

// VULNERABLE — anyone can become owner, then drain the vault
contract Vault {
    address public owner;
    constructor() { owner = msg.sender; }

    function setOwner(address newOwner) public {   // <-- no access check!
        owner = newOwner;
    }

    function withdraw() public {
        require(msg.sender == owner, "not owner");
        payable(owner).transfer(address(this).balance);
    }
}

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

// FIXED — ownership can only move via Ownable's onlyOwner-guarded path
contract Vault is Ownable {
    constructor() Ownable(msg.sender) {}

    function withdraw() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
    // transferOwnership(newOwner) comes from Ownable and is itself onlyOwner
}

// VULNERABLE wallet — authorizes by tx.origin
contract Wallet {
    address public owner = msg.sender;
    function transferTo(address payable to, uint256 amount) public {
        require(tx.origin == owner, "not owner");   // <-- BUG
        to.transfer(amount);
    }
}

// Attacker's bait: the owner is tricked into calling attack()
contract Phish {
    Wallet immutable victim;
    address payable immutable attacker;
    constructor(Wallet _victim) {
        victim = _victim;
        attacker = payable(msg.sender);
    }
    function attack() external {                     // looks like "claim reward"
        victim.transferTo(attacker, address(victim).balance);
        // msg.sender here is Phish, but tx.origin is still the owner -> passes
    }
}

// Simplified Parity WalletLibrary — delegatecalled by every wallet
contract WalletLibrary {
    address public owner;

    // meant to run ONCE at wallet creation — but nothing enforces that
    function initWallet(address _owner) public {
        owner = _owner;               // <-- re-ownable by anyone, anytime
    }

    function kill(address payable to) public {
        require(msg.sender == owner, "not owner");
        selfdestruct(to);             // removes this contract's code
    }
}

contract WalletLogic {
    address public owner;
    bool private initialized;

    function initialize(address _owner) external {
        require(!initialized, "already initialized");
        initialized = true;           // can never run a second time
        owner = _owner;
    }
}

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

contract Vault is Initializable, OwnableUpgradeable, UUPSUpgradeable {
    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();        // implementation can NEVER be initialized
    }

    function initialize(address admin) public initializer {
        __Ownable_init(admin);         // runs once, on the proxy only
        __UUPSUpgradeable_init();
    }

    // who may upgrade the logic — the most privileged action of all
    function _authorizeUpgrade(address) internal override onlyOwner {}
}

import "@openzeppelin/contracts/access/AccessControl.sol";

contract Token is AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

    constructor(address admin) {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);   // can manage all roles
    }

    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }
}