How the Reentrancy Attack Works

How the Reentrancy Attack Works


A reentrancy attack is a critical security vulnerability in smart contracts, allowing attackers to manipulate contract state, drain funds, or cause other unintended behaviors. Understanding how these attacks work and how to prevent them is crucial for maintaining the integrity and security of blockchain projects. According to recent statistics, reentrancy attacks accounted for over $30 million in losses in 2023 alone source.

How the Reentrancy Attack Works

A reentrancy attack exploits the sequential execution of operations in systems like Ethereum, where multiple operations can occur within a single transaction before state changes are finalized. This attack targets functions in smart contracts that change the contract’s state and perform critical actions, such as transferring assets.

Example Scenario:

Consider a smart contract with a withdraw function that sends Ether to the caller before updating its internal balance mapping. The vulnerability arises because the transfer of Ether (e.g.,{value: balances[msg.sender]}("")) is performed before updating the balance (balances[msg.sender] = 0). This sequence allows an attacker to re-enter the withdraw function before the balance is updated, enabling multiple withdrawals within a single transaction.

Reentrancy Attack Steps

  1. Deploy a Malicious Contract: The attacker deploys a malicious contract designed for repeated calls.
  2. Initiate the Attack: The attacker calls the vulnerable function to transfer tokens.
  3. Trigger Reentrant Call: The attacker’s contract makes a reentrant call via an external contract call back into the same function before the critical state change is finalized.
  4. Exploit Incomplete State: The critical state change (e.g., balance update) hasn’t been completed yet, allowing the attacker to exploit the incomplete state.
  5. Repeat: This process is repeated multiple times within a single transaction, amplifying the attack’s impact and causing severe damage to the contract’s integrity and funds.

Preventing Reentrancy Attacks

Use Checks-Effects-Interactions Pattern

One effective way to prevent reentrancy attacks is to employ the "checks-effects-interactions" pattern in smart contract development. This pattern involves organizing the function logic into three distinct phases:

  1. Checks: Validate all necessary conditions before proceeding with the function logic. This ensures that all prerequisites are met, preventing unintended behavior.
  2. Effects: Update the contract’s state variables before making any external calls. This guarantees that the contract’s state reflects the intended changes before any external interactions occur.
  3. Interactions: Interact with other contracts or perform external calls. Since the state has already been updated, any reentrant call will see the correct state, mitigating the risk of reentrancy.

Use Function Modifiers that Prevent Reentrancy

Another method to protect against reentrancy attacks is to use function modifiers that prevent reentrancy. A reentrancy guard can be implemented using a simple boolean lock mechanism. This involves creating a modifier that sets a lock before the function execution begins and releases it after the function has completed.


Reentrancy attacks pose a significant threat to the security and integrity of smart contracts. By understanding how these attacks work and implementing preventive measures such as the checks-effects-interactions pattern and function modifiers, developers can safeguard their contracts against such vulnerabilities. Ensuring robust security practices is essential for maintaining trust and reliability in the blockchain ecosystem.


1. What is a reentrancy attack?

  • A reentrancy attack is a security vulnerability in smart contracts where an attacker can repeatedly call a function before state changes are finalized, potentially manipulating the contract's state.

2. How does a reentrancy attack work?

  • It works by making a recursive call to the original function via an external contract before the critical state change is completed, allowing the attacker to exploit the incomplete state.

3. What is the checks-effects-interactions pattern?

  • It is a coding pattern that involves validating conditions (checks), updating state variables (effects), and then interacting with external contracts (interactions) to prevent reentrancy attacks.

4. How can function modifiers prevent reentrancy attacks?

  • Function modifiers can implement a reentrancy guard using a boolean lock mechanism to prevent a function from being re-entered while it is still executing.

5. Why is it important to prevent reentrancy attacks?

  • Preventing reentrancy attacks is crucial to maintain the security, integrity, and reliability of smart contracts, protecting them from manipulation and financial loss.

Continue reading