Ethernaut 챌린지: 폴백 스마트 컨트랙트 해킹하기

### 이노넛 챌린지 해킹하기: 레벨 1 - 폴백
* 🔍 오늘 저희는 스마트 컨트랙트의 폴백 기능을 악용하여 소유권을 주장하고 잔액을 소진하는 데 초점을 맞춘 **'폴백'으로 알려진 Ethernaut 챌린지 레벨 1**을 다루었습니다.
* 💻 컨트랙트는 **'message.sender'로 설정된 소유자와 1,000 이더로 초기화**되며, **0.001 이더 미만의 기여**를 허용하는 '기여' 기능도 함께 제공됩니다.
* ⚖ 소유권을 주장하려면 현재 소유자의 기여도를 초과해야 하지만, **소유자의 기여도가 1,000이더**이므로 일반적으로 **1,000개 이상의 트랜잭션**이 필요합니다.
* 📬 컨트랙트에는 특정 함수 호출 없이 이더를 전송할 때 트리거되는 '수신' 함수가 있어 **조건이 충족되면 소유자를 변경**할 수 있습니다.
* 💰 컨트랙트의 새 인스턴스를 생성한 후, 저희의 기여도가 0보다 큰지 확인하기 위해 **약간의 기여**를 했고, 이를 통해 **이더를 컨트랙트 주소로 전송**할 수 있었습니다.
* ✅ 소량의 이더를 전송한 후 **'contract.owner'가 플레이어 주소와 일치하는지 확인**하여 소유권을 확인했고, 첫 번째 요건을 충족했습니다.
* 🚀 소유권이 확인되면 **'출금' 기능을 호출하여 전체 잔액을 본인에게 이체**하여 계약 잔액을 0으로 줄이는 데 성공했습니다.
* 🔑 이 문제를 통해 **폴백 기능의 취약점**이 부각되었고, 이로 인해 의도된 기여 방식을 우회하여 **소유권 및 자금에 대한 계약을 악용**할 수 있게 되었습니다.

Ethernaut 챌린지는 플레이어가 폴백 기능을 조작하여 스마트 컨트랙트를 악용하여 소유권을 얻고 자금을 인출하는 방법을 가르칩니다.

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

챌린지 개요: Ethernaut 레벨 1 - 폴백

"폴백"이라는 제목의 Ethernaut 레벨 1을 소개합니다.

목표: 계약 소유권을 주장하고 잔액을 0으로 줄입니다.

컨트랙트 함수: '기여', 'getContribution', '출금', '수신'.

도전 난이도:  소유자가 되려면 소유자의 이더리움 기부금이 1000 이더를 초과해야 하며, 거래는 0.001 이더 미만으로 제한됩니다.

잠재적인 익스플로잇으로 '수신' 기능에 집중하세요.

새 컨트랙트 인스턴스를 생성하고 초기 소유자를 확인합니다.

'받기' 함수를 사용하려면 0보다 큰 기여도가 필요합니다.

'contract.contribute'를 사용하여 소량의 웨이를 기부합니다.

getContribution` 함수 호출을 수정하고 wei를 Ether로 변환합니다.

메타마스크를 통해 소량의 이더를 컨트랙트 주소로 전송합니다.

'contract.withdraw'를 사용하여 자금 출금하기.

출금 후 계약 잔액이 0인지 확인합니다.

확인을 위해 인스턴스를 제출하고 레벨을 통과합니다.

오픈제플린의 자체 계약과 그 취약성에 대해 논의합니다.

폴백` 기능의 익스플로잇에 대한 설명입니다.

다음 단계인 '폴아웃'의 결론 및 미리 보기.