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**.

Hello everyone, today we're doing the Ethernaut challenge level one. This one's called "Fallback". If you haven't already, go check out the level zero video we did to know how to set up Ethernaut and today we're going to hack this smart contract by the name it suggests, something to do

with the fallback function. But let's check it out. So it says "Look carefully at the contracts code below and we will beat this level if we can claim the ownership of this contract and we can reduce its balance to zero." So essentially we have this contract called "Fallback", uh, with sets

and owner available during the constructor to message.sender and it sets the contribution to a thousand Ether for this message.sender. Then we have an only owner modifier and then we have a few different functions. So a function called "contribute" which can add to the contributions of whoever

calls this function, then it needs to be less than 0.001 Ether. And if contributions of this message.sender is greater than the contributions of the owner, then the owner is updated. Okay, so we know something needs to happen over here. We need to update the owner and

this function seems to update the owner if the contributions are greater than the owner. However, this is a little bit tricky because the contributions of the owner are initially set to a thousand Ether, whereas in the contribute function we can only send values less than 0.001

Ether. So it will take more than a thousand transactions, even if we were to do this manually, to get to the point where our contribution is more than the owner. Okay, so there's something here and we have a "getContribution" function that just shows the contributions and then we have a

withdrawal function that's that can be called by the owner which transfers all of the balance out so this is also something we need to do to reduce the balance to zero but we can only do this after we successfully become the owner and then there's a receive function

which is like a default sort of fallback function um which requires message.value is greater than zero and our contribution is greater than zero which also changes the owner interesting okay so the way the receive function works is you just send some ETH to this contract address and then since we're not

explicitly calling a function when we're sending ETH um the receive function is automatically called it's kind of like the default sort of catch-all function and if your smart contract doesn't have a receive function or a fallback function then actually you cannot send it directly to

the contract that transaction will just fail okay so let's start I'm going to get a new instance so we have a contract to play around with and let's wait for this transaction to be mined awesome so we have a new instance this is the contract address

and we can check uh wait contract dot owner and you'll see this current owner address is not the same as my player address right so we need to send this contract we're going to use this receive function to send this contract some ETH and it will update the owner to us however to

do that we need to meet this required condition so message dot value is greater than zero that's okay we'll just send it a small amount of ETH and contributions message dot sender is greater than zero so to make this true we need to first contribute something to the contract to

bump up our contribution value and we'll just send it a small amount of wei so we'll just do await contract dot contribute and we will send it a value of um two wei and 0.0001 all right so we're uh two wei by the way is a helper

function that's available in the console browser and it converts an ethereum ether amount to wei so it converts like 0.001 ether into wei which is what solidity expects and then we click confirm and we wait for this transaction to be mined all right so the transaction has

now been mined let's check what our contribution is at now so we do a weight contract dot get contribution and we'll do the player address and it says invalid argument HEX number with leading zero digits interesting um all right okay so it doesn't actually expect a

parameter so we just do that was my bad we just need to do get contribution it doesn't actually take a parameter at all and we see in this value it's greater than zero right this is a object it's returning I'm guessing it's some sort of like big

number thing or something um so we can maybe do a from wei over here um so from wei await on track dot get contribution yeah and it says 0.0001 so this returns us wei it's kind of like a big number because it returns

a uint256 and you in 256 can possibly be a really large number much more than what JavaScript can handle by itself so instead of sending a regular number like zero one two three four in JavaScript it sends this like big number object which breaks it down which breaks it down

breaks the number down into, um, sort of a different encoding and then we can convert that into a more human-readable encoding, which is this, um, which is exactly the amount of heat we contributed earlier. All right, so now that our contributions are greater than zero, let's just send this address some

ETH. So take the contract address and I'm going to copy this contract address and I'll go to MetaMask and I'll send this contract address a tiny little amount of ETH, so 0.0001. It doesn't really matter, you can send whatever, it just wants it to be

greater than zero. So you just send it a tiny amount and we will wait for this transaction to be mined. Awesome. So the transaction has now been mined. So at this point, given the transaction did not fail, we should have become the owner. So let's check that.

First of all, I'm going to print out the player address and then we'll do `await contract.owner` once, and you see my address is the same as `contract.owner` now. So we've fulfilled the first requirement of this level where we've claimed ownership of the contract and now we

need to reduce its balance to zero. So we can do that pretty easily now that we're the owner. We just need to call `contract.withdraw`, and this will send us all the ETH that the contract has at this point. So wait for this transaction to be mined.

Awesome. So the transaction has been mined. So you can see in this function what it's doing. It's taking the owner address and it's transferring it the balance of this, which is the smart contract itself. So at this point, I should have received back the ETH I contributed.

earlier, but anyway, we should have met both the conditions now. Um, actually what we can do is we can get the balance of the contract to make sure it's now zero. Um, oh, the, oh, it needs to be contract.address right, so you do a way to get balance contract

dot address and you see it's now zero. So you've claimed ownership and we've reduced the balance of the contract to zero. I'm going to go ahead and submit the instance now for verification and click confirm and wait for this transaction to be mined.

Perfect, so the transaction has been mined and amazing, we've successfully passed this level. Uh, we've learned about the OpenZeppelin's ownable contract and how it can be used to restrict the usage of some methods to a privileged address, which is typically the only owner.

modifier. The bug in this contract obviously is the fact that in the fallback function, it just updates the owner if this required condition is met. So typically if this wasn't here, then the only way to become an owner would have been to do a lot of contributions

over and over again, and since it starts out uh with the contribution of 1,000 ETH for the owner having to do it over and over again would take a lot of transactions, given we can only send a small amount of ETH per transaction to it. Uh, that would be painstaking. It would

be possible assuming you have 1,000 testnet ETH for some reason, um, or slightly more than 1,000 testnet ETH for some reason, and it would be possible, but that may have been the intended way this contract is supposed to work, but the problem is in this

receive function, it has this line, assuming we make these conditions, and we were able to exploit that to become the owner and then withdraw all its money without needing to send it a thousand ETH. Awesome! So I hope you learned something and I will see you in the next

level which is going to be Fallout. [Music]

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".