Key Security Takeaways:

Do NOT use tx.origin for authorization
Be careful with using direct mathematical operations
Be VERY careful when using deletgatecall. You are essentially trusting the functions of the called contract.
Beware & careful with selfdestruct because all ETH in a selfdestructed contract will be gone forever.
All the storage is visible on a public blockchain, including the variables declared as private

This post is part 2 of the Ethernaut series. To learn more about the Ethernaut game and the first three levels, head over here. I'm sharing my notes as I go along 😊

Screen Shot 2022-07-26 at 11.25.45.png

In this post, I want to go over challenges 4, 5, 6 & 7 of the Ethernaut Game. Here are the key terms that we will be covering:

Global variable tx.origin vs. msg.sender
Arithmetic underflows & overflows (error handling in solidity version 0.8 & above)
Delegatecall
selfdestruct
Storage in Solidity

1. Telephone

Goal: Claim ownership of the contract below to complete this level.

The goal is to become the owner of the given smart contract.

Based on the challenge, the part of the smart contract that we are interested in is the changeOwner(address _owner) function.

  function changeOwner(address _owner) public {
    if (tx.origin != msg.sender) {
      owner = _owner;
    }

Key Concepts

tx.origin: a global variable that is the starter of the transaction, this must be an externally owned account (EOA) which is a wallet address. Only an EOA can initiate a transaction.
msg.sender: a global variable that represents the immediate account making the function call (can be a smart contract account or an externally owned account). This can be a smart contract account or an EOA.

Screen Shot 2022-09-03 at 22.28.30.png

Phishing Attack: is a type of cybersecurity attack in which the attacker disguises as a trustworthy entity and tries to manipulate the user. You may have heard of phishing emails, where malicious actors send emails to trick people into clicking on links.
Ethereum Transactions: Small note that when a transaction is sent, this can then call another function and start different transactions. (We can have a series of transactions that start from a single user executing one function.) So, for example, you can start a transaction from your wallet, and that can invoke another transaction via a function call on a smart contract and so on. Tx.origin will be your wallet address in this case. Msg.sender will be the immediate account that made the last transaction call.

Basically, the way to win the challenge is to pass the following condition: "tx.origin != msg.sender." To do this, we need an intermediate contract. Let's get to the solution & cover it in detail.

Solution

On the page, right-click & select "Inspect." This will open the google developer console; we'll use this to interact with the contact.
Click "Get a new Instance." Once you click the button, approve the popup on your MetaMask & pay for the transaction.

If all goes well, you should be able to see the smart contract address on the Console.

🥷 How to hack this contract: We need to manipulate who starts the transaction. When we create a new smart contract that sits in between the account starting the transaction, then tx.origin will no longer equal msg.sender. Once this condition is satisfied, the owner can be changed to the address that is passed in the changeOwner function.
We need to deploy a new smart contract. Go to Remix IDE. First, import the Telephone smart contract to remix by copying and pasting the contract and calling it Telephone.sol.
Create a new smart contract called: TelephoneAttack.sol

Here is what the contract should look like:

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import './Telephone.sol';

contract TelephoneAttack {

Telephone telephoneContract;

constructor(address _address) public {
  telephoneContract = Telephone(_address);
}

function hackContract(address _address) public {
  telephoneContract.changeOwner(_address);
 }
}

It's time to compile the smart contract. On the Solidity compiler tab, click compile to compile the TelephoneAttack contract.
On Remix, change the environment to Injected Metamask. This way, we can deploy the contract from our MetaMask wallet.
Get the TelephoneAttack contract address from Ethernaut.
Time to deploy the smart contract. Add the TelephoneAttack address on the deploy interface and deploy the contract. This way, we will set the attacker contract. Next, you'll need to approve the popup on your MetaMask wallet.

Once the contract is deployed you can view it on the "Deploy & Run Contract" tab.
Call the hackContract function with your wallet address (also called the player address). You will need to approve the popup on your wallet.

You can check the owner from the Ethernaut page from the inspect tab by the following:
```
await contract.owner()
```
If all goes well, you should be the new owner of the contract! Don't forget to submit your instance to get the completion message from Ethernaut!

🌟 Takeaway

Do NOT use tx.origin for authorization! This makes the smart contract vulnerable to phishing attacks since the attacker can trick someone into starting the transaction. You can read more on the security considerations page over here.

2. Token

Please note: This challenge can probably be deprecated, but it's good knowledge, so I've left it here. It's about arithmetic overflow vulnerabilities, and starting from Solidity versions 0.8, the compiler throws an error for arithmetic overflows/underflows, handling the error. Before the 0.8 version, Solidity would not give an error. Now the compiler automatically solves such errors if you are using version 0.8. or above.

Goal: The goal of this level is for you to hack the basic token contract below. You are given 20 tokens to start with and you will beat the level if you somehow manage to get your hands on any additional tokens. Preferably a very large amount of tokens.