Reentrancy attacks in Blockchain / Solidity - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a reentrancy attack in blockchain smart contracts?

A reentrancy attack happens when a smart contract calls another contract that calls back into the original contract before the first call finishes, allowing repeated withdrawals or actions that can drain funds or cause unexpected behavior.

beginner

Why are reentrancy attacks dangerous?

They let attackers repeatedly withdraw funds or manipulate contract state before the contract updates its balance or state, leading to loss of money or corrupted data.

intermediate

What is the common pattern to prevent reentrancy attacks?

Use the 'checks-effects-interactions' pattern: first check conditions, then update state, and only after that interact with other contracts or send funds.

intermediate

How does the 'ReentrancyGuard' contract help prevent attacks?

It uses a lock mechanism to prevent a contract function from being called again before the first call finishes, blocking reentrant calls.

advanced

Give a simple example of a vulnerable Solidity function to reentrancy.

A function that sends Ether to a user before updating their balance, like: <pre>function withdraw(uint amount) public { require(balances[msg.sender] >= amount); (bool success, ) = msg.sender.call{value: amount}(""); require(success); balances[msg.sender] -= amount; }</pre> This allows reentrancy because balance is updated after sending Ether.

What is the main cause of a reentrancy attack?

A Sending Ether without a fallback function

B Using too much gas in a transaction

C Not verifying user input

D Calling an external contract before updating state

Reentrancy attacks happen when a contract calls another contract before updating its own state, allowing the called contract to call back and exploit the original contract.

Which pattern helps prevent reentrancy attacks?

A Event logging

B Checks-Effects-Interactions

C Lazy loading

D Gas optimization

The Checks-Effects-Interactions pattern ensures state changes happen before external calls, preventing reentrancy.

What does the ReentrancyGuard contract do?

A Prevents multiple calls to a function at the same time

B Encrypts contract data

C Limits gas usage

D Automatically updates balances

ReentrancyGuard uses a lock to prevent a function from being reentered before the first call finishes.

In Solidity, what is a risky way to send Ether that can cause reentrancy?

A Using call.value() without updating state first

B Using transfer() after updating state

C Using send() with a gas limit

D Using payable fallback functions

Using call.value() (or call with value) before updating state allows the called contract to reenter and exploit the contract.

Which of these is NOT a way to prevent reentrancy?

A Update state before external calls

B Use mutex locks like ReentrancyGuard

C Allow multiple reentrant calls

D Avoid external calls entirely

Allowing multiple reentrant calls is exactly what causes reentrancy attacks, so it is not a prevention method.

Explain what a reentrancy attack is and why it can cause loss of funds in smart contracts.

Think about a contract calling another contract that calls back before state updates.

Describe the 'checks-effects-interactions' pattern and how it helps prevent reentrancy attacks.

Focus on the order of operations in a function.