第九章：智能合约安全

// 示例1：经典重入攻击
contract VulnerableVault {
    mapping(address => uint256) public balances;
    
    // 基础版漏洞：状态更新在外部调用之后
    function withdraw(uint256 amount) external {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        // 危险：先转账，后更新状态
        (bool success,) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
        
        balances[msg.sender] -= amount;  // 攻击者可以在此之前再次调用withdraw
    }
}

// 修复版：检查-生效-交互模式
contract SecureVault {
    mapping(address => uint256) public balances;
    
    function withdraw(uint256 amount) external {
        // 检查
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        // 生效：先更新状态
        balances[msg.sender] -= amount;
        
        // 交互：最后进行外部调用
        (bool success,) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// 进阶版：只读重入攻击
contract ReadOnlyReentrancy {
    uint256 public totalShares;
    mapping(address => uint256) public shares;
    
    // 漏洞：在外部调用期间，totalShares可能不准确
    function withdraw() external {
        uint256 userShares = shares[msg.sender];
        require(userShares > 0, "No shares");
        
        // 计算份额价值
        uint256 value = (address(this).balance * userShares) / totalShares;
        
        // 更新状态
        shares[msg.sender] = 0;
        totalShares -= userShares;
        
        // 外部调用
        IExternalContract(externalContract).notifyWithdrawal(msg.sender, value);
        // 问题：如果notifyWithdrawal调用了getSharePrice()，
        // 它会看到更新后的totalShares，但余额还没有转出
        
        payable(msg.sender).transfer(value);
    }
    
    // 只读函数，但可能返回不一致的状态
    function getSharePrice() external view returns (uint256) {
        if (totalShares == 0) return 0;
        return address(this).balance / totalShares;
    }
}

// 完全修复版：使用ReentrancyGuard
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract FullySecureVault is ReentrancyGuard {
    mapping(address => uint256) public shares;
    uint256 public totalShares;
    
    function withdraw() external nonReentrant {
        uint256 userShares = shares[msg.sender];
        require(userShares > 0, "No shares");
        
        uint256 value = (address(this).balance * userShares) / totalShares;
        
        shares[msg.sender] = 0;
        totalShares -= userShares;
        
        // nonReentrant修饰符保护所有外部调用
        IExternalContract(externalContract).notifyWithdrawal(msg.sender, value);
        payable(msg.sender).transfer(value);
    }
}

// 正确的权限设计
contract SecureStablecoin {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant ORACLE_ROLE = keccak256("ORACLE_ROLE");
    
    // 细粒度的角色分离
    modifier onlyRole(bytes32 role) {
        require(hasRole(role, msg.sender), "Unauthorized");
        _;
    }
    
    function mint(address to, uint256 amount) 
        external 
        onlyRole(MINTER_ROLE) 
        whenNotPaused 
    {
        _mint(to, amount);
    }
    
    // 时间锁保护的关键操作
    uint256 public constant TIMELOCK_DURATION = 48 hours;
    mapping(bytes32 => uint256) public timelockProposals;
    
    function proposeNewMinter(address newMinter) external onlyRole(DEFAULT_ADMIN_ROLE) {
        bytes32 proposalId = keccak256(abi.encodePacked("ADD_MINTER", newMinter));
        timelockProposals[proposalId] = block.timestamp + TIMELOCK_DURATION;
    }
}

contract DefensiveStablecoin {
    using SafeMath for uint256;
    
    // 状态变量的显式初始化
    bool private initialized = false;
    uint256 public constant MAX_SUPPLY = 1e12 * 1e18; // 1万亿上限
    
    // 防重入保护
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;
    uint256 private reentrancyStatus = NOT_ENTERED;
    
    modifier nonReentrant() {
        require(reentrancyStatus != ENTERED, "ReentrancyGuard: reentrant call");
        reentrancyStatus = ENTERED;
        _;
        reentrancyStatus = NOT_ENTERED;
    }
    
    // 输入验证
    function transfer(address to, uint256 amount) public returns (bool) {
        require(to != address(0), "Transfer to zero address");
        require(to != address(this), "Transfer to contract itself");
        require(amount > 0, "Transfer amount must be positive");
        require(amount <= balanceOf(msg.sender), "Insufficient balance");
        
        _transfer(msg.sender, to, amount);
        return true;
    }
    
    // 检查-影响-交互模式（CEI）
    function withdraw(uint256 amount) external nonReentrant {
        // 检查
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        // 影响（先更新状态）
        balances[msg.sender] = balances[msg.sender].sub(amount);
        totalSupply = totalSupply.sub(amount);
        
        // 交互（最后进行外部调用）
        (bool success,) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// 使用 SMTChecker 和断言进行形式化验证
contract FormallyVerifiedStablecoin {
    mapping(address => uint256) public balances;
    uint256 public totalSupply;
    
    // 不变量：所有余额之和等于总供应量
    function invariant_totalSupply() private view {
        uint256 sum = 0;
        // 注意：实际中需要遍历所有地址
        // 这里用断言表示概念
        assert(sum == totalSupply);
    }
    
    function transfer(address to, uint256 amount) public {
        require(to != address(0));
        
        uint256 oldFromBalance = balances[msg.sender];
        uint256 oldToBalance = balances[to];
        
        require(oldFromBalance >= amount);
        
        balances[msg.sender] = oldFromBalance - amount;
        balances[to] = oldToBalance + amount;
        
        // 后置条件验证
        assert(balances[msg.sender] == oldFromBalance - amount);
        assert(balances[to] == oldToBalance + amount);
        
        // 保持不变量
        invariant_totalSupply();
    }
}

// 规范语言示例（用注释表示）
contract Specification {
    /// @custom:formal-verification
    /// @pre balances[msg.sender] >= amount
    /// @post balances[msg.sender] == old(balances[msg.sender]) - amount
    /// @post balances[to] == old(balances[to]) + amount
    /// @post totalSupply == old(totalSupply)
    function transfer(address to, uint256 amount) external;
}

// 透明代理模式（OpenZeppelin标准）
contract TransparentUpgradeableProxy {
    // EIP-1967 标准存储槽
    bytes32 private constant _IMPLEMENTATION_SLOT = 
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    bytes32 private constant _ADMIN_SLOT = 
        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
    
    modifier ifAdmin() {
        if (msg.sender == _getAdmin()) {
            _;
        } else {
            _fallback();
        }
    }
    
    function upgradeTo(address newImplementation) external ifAdmin {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCall(newImplementation, bytes(""), false);
    }
    
    function _authorizeUpgrade(address newImplementation) internal {
        // 安全检查
        require(newImplementation != address(0), "Invalid implementation");
        require(newImplementation.code.length > 0, "Implementation not contract");
        
        // 可选：检查新实现的初始化状态
        (bool success, bytes memory data) = newImplementation.staticcall(
            abi.encodeWithSignature("proxiableUUID()")
        );
        require(success && data.length == 32, "Not UUPS compliant");
    }
}

// UUPS模式（更gas高效但风险更高）
contract UUPSUpgradeable {
    function _authorizeUpgrade(address newImplementation) internal virtual;
    
    function upgradeTo(address newImplementation) external {
        _authorizeUpgrade(newImplementation);
        
        // 关键安全检查：防止升级到恶意合约
        require(
            bytes32(newImplementation.codehash) != bytes32(0),
            "New implementation must be contract"
        );
        
        // 检查存储布局兼容性
        _checkStorageLayout(newImplementation);
        
        // 执行升级
        assembly {
            sstore(_IMPLEMENTATION_SLOT, newImplementation)
        }
    }
    
    function _checkStorageLayout(address newImplementation) private view {
        // 使用storage gap确保升级安全
        uint256[50] private __gap;
        
        // 验证关键存储变量的位置
        // 这需要链下工具支持
    }
}

// 实时监控系统
import { ethers } from 'ethers';
import { WebhookClient } from 'discord.js';
import { Defender } from '@openzeppelin/defender-sdk';

class StablecoinMonitor {
    private provider: ethers.Provider;
    private contract: ethers.Contract;
    private alerts: WebhookClient;
    private defender: Defender;
    
    // 监控阈值
    private readonly LARGE_TRANSFER_THRESHOLD = ethers.parseEther('1000000'); // 100万
    private readonly PRICE_DEVIATION_THRESHOLD = 0.02; // 2%
    private readonly UNUSUAL_GAS_MULTIPLIER = 3;
    
    constructor(config: MonitorConfig) {
        this.provider = new ethers.JsonRpcProvider(config.rpcUrl);
        this.contract = new ethers.Contract(
            config.contractAddress,
            config.abi,
            this.provider
        );
        this.alerts = new WebhookClient({ url: config.webhookUrl });
        this.defender = new Defender(config.defenderCredentials);
    }
    
    async startMonitoring() {
        // 监控大额转账
        this.contract.on('Transfer', async (from, to, value, event) => {
            if (value > this.LARGE_TRANSFER_THRESHOLD) {
                await this.alertLargeTransfer(from, to, value, event);
            }
            
            // 检查可疑模式
            await this.checkSuspiciousPatterns(from, to, value);
        });
        
        // 监控价格偏离
        setInterval(() => this.checkPriceDeviation(), 60000); // 每分钟
        
        // 监控异常Gas使用
        this.provider.on('block', async (blockNumber) => {
            await this.checkGasAnomalies(blockNumber);
        });
        
        // 监控合约暂停事件
        this.contract.on('Paused', async (account) => {
            await this.alertEmergency('Contract Paused', {
                by: account,
                timestamp: new Date().toISOString()
            });
        });
    }
    
    private async checkSuspiciousPatterns(
        from: string, 
        to: string, 
        value: bigint
    ) {
        // 检查闪电贷模式
        const fromCode = await this.provider.getCode(from);
        const toCode = await this.provider.getCode(to);
        
        if (fromCode !== '0x' && toCode !== '0x') {
            // 两个合约之间的大额转账
            const block = await this.provider.getBlock('latest');
            const recentTxs = await this.getRecentTransactions(from, 10);
            
            // 检查循环模式
            const hasCircularPattern = recentTxs.some(tx => 
                tx.to?.toLowerCase() === to.toLowerCase() &&
                tx.from.toLowerCase() === from.toLowerCase()
            );
            
            if (hasCircularPattern) {
                await this.alertSuspicious('Potential Flash Loan Attack', {
                    from,
                    to,
                    value: ethers.formatEther(value),
                    pattern: 'circular transfers detected'
                });
            }
        }
        
        // 检查新创建的合约
        const toAge = await this.getContractAge(to);
        if (toCode !== '0x' && toAge < 3600) { // 小于1小时
            await this.alertSuspicious('Transfer to New Contract', {
                contract: to,
                age: `${toAge} seconds`,
                value: ethers.formatEther(value)
            });
        }
    }
    
    private async checkPriceDeviation() {
        try {
            const oraclePrice = await this.contract.getOraclePrice();
            const targetPrice = ethers.parseEther('1'); // $1
            
            const deviation = Number(
                ((oraclePrice - targetPrice) * 10000n) / targetPrice
            ) / 10000;
            
            if (Math.abs(deviation) > this.PRICE_DEVIATION_THRESHOLD) {
                await this.alertPriceDeviation(deviation, oraclePrice);
                
                // 自动触发防御措施
                if (Math.abs(deviation) > 0.05) { // 5%
                    await this.triggerEmergencyAction('pause');
                }
            }
        } catch (error) {
            console.error('Price check failed:', error);
        }
    }
    
    private async triggerEmergencyAction(action: string) {
        // 使用OpenZeppelin Defender执行紧急操作
        try {
            const response = await this.defender.relaySigner.sendTransaction({
                to: this.contract.address,
                data: this.contract.interface.encodeFunctionData(action),
                speed: 'fast',
                gasLimit: 100000
            });
            
            await this.alertEmergency(`Emergency ${action} triggered`, {
                txHash: response.hash,
                reason: 'Automatic protection activated'
            });
        } catch (error) {
            console.error('Emergency action failed:', error);
        }
    }
    
    private async alertLargeTransfer(
        from: string, 
        to: string, 
        value: bigint, 
        event: any
    ) {
        const embed = {
            title: '⚠️ Large Transfer Detected',
            color: 0xFFCC00,
            fields: [
                { name: 'From', value: from, inline: true },
                { name: 'To', value: to, inline: true },
                { name: 'Amount', value: `${ethers.formatEther(value)} tokens` },
                { name: 'Transaction', value: event.transactionHash },
                { name: 'Block', value: event.blockNumber.toString() }
            ],
            timestamp: new Date().toISOString()
        };
        
        await this.alerts.send({ embeds: [embed] });
    }
}

// 应急响应计划
class IncidentResponse {
    private readonly actions = {
        'price-deviation': ['pause-minting', 'increase-fees', 'alert-team'],
        'large-withdrawal': ['check-reserves', 'prepare-liquidity', 'monitor-closely'],
        'smart-contract-exploit': ['pause-all', 'snapshot-state', 'prepare-upgrade'],
        'oracle-failure': ['switch-oracle', 'use-twap', 'manual-override']
    };
    
    async executeResponsePlan(incidentType: string, severity: 'low' | 'medium' | 'high' | 'critical') {
        const plan = this.actions[incidentType] || ['alert-team'];
        
        for (const action of plan) {
            await this.executeAction(action, severity);
        }
    }
    
    private async executeAction(action: string, severity: string) {
        console.log(`Executing ${action} for ${severity} incident`);
        // 实现具体的响应动作
    }
}