Ethernaut Challenge: Hacking the Fallback Smart Contract

The Ethernaut challenge teaches players to exploit smart contracts by manipulating fallback functions to gain ownership and withdraw funds.

### Hacking the Ethernaut Challenge: Level One - Fallback
* 🔍 Today, we tackled the Ethernaut challenge level one, known as "Fallback," focusing on **exploiting the smart contract's fallback function** to **claim ownership and drain its balance**.
* 💻 The contract initializes with an owner set to `message.sender` and a contribution of **1,000 Ether**, along with a `contribute` function that allows contributions of **less than 0.001 Ether**.
* ⚖ To claim ownership, our contribution must **exceed that of the current owner**, but since the owner's contribution is **1,000 Ether**, this would typically require **over a thousand transactions**.
* 📬 The contract features a **`receive` function** that is triggered when Ether is sent without a specific function call, allowing us to potentially **change the owner if conditions are met**.
* 💰 After creating a new instance of the contract, we made a small contribution to ensure our contribution was **greater than zero**, which allowed us to **send Ether to the contract address**.
* ✅ Once we sent a tiny amount of Ether, we confirmed our ownership by checking that `contract.owner` matched our player address, fulfilling the **first requirement**.
* 🚀 With ownership confirmed, we called the `withdraw` function to **transfer the entire balance to ourselves**, successfully reducing the contract's balance to **zero**.
* 🔑 This challenge highlighted the **vulnerability in the fallback function**, which allowed us to **bypass the intended contribution method** and **exploit the contract for ownership and funds**.

Stealing ETH by sending ETH to a smart contract - Ethernaut Level 1 - Fallback

LearnWeb3

Challenge Overview: Ethernaut Level One - Fallback

Introduction to Ethernaut Level One, titled "Fallback".

Objective: Claim contract ownership and reduce its balance to zero.

Contract functions: `contribute`, `getContribution`, `withdrawal`, and `receive`.

Challenge difficulty:  Becoming owner requires exceeding owner's 1000 Ether contribution with transactions limited to <0.001 Ether.

Focus on the `receive` function as a potential exploit.

Creating a new contract instance and verifying the initial owner.

Utilizing the `receive` function requires a contribution greater than zero.

Contributing a small amount of wei using `contract.contribute`.

Correcting the `getContribution` function call and converting wei to Ether.

Sending a small amount of ETH to the contract address via MetaMask.

Verification of ownership change after sending ETH.

Withdrawing funds using `contract.withdraw`.

Verifying the contract balance is zero after withdrawal.

Submitting the instance for verification and passing the level.

Discussion of OpenZeppelin's ownable contract and its vulnerability.

Explanation of the exploit in the `fallback` function.

Conclusion and preview of the next level, "Fallout".