Common Vulnerabilities in Solidity: Selfdestruct Function

Mar 25, 2023

In the field of blockchain, smart contracts are considered as a revolutionary technology that enables the automatic execution of various complex transactions and operations on decentralized networks. However, with the widespread adoption of smart contracts, security issues have become increasingly prominent. The design and implementation of smart contracts often involve many potential security risks, one of which is the selfdestruct function vulnerability.

This article will introduce the basic concepts of smart contract selfdestruct function vulnerability, analyze the possible security issues they may cause, and provide some suggestions on how to avoid such vulnerability. We hope that through the discussion in this article, developers and users will have a better understanding of smart contract selfdestruct function vulnerability, thereby promoting the overall security of the blockchain ecosystem.

What Is Selfdestruct Function ?

In smart contracts, the selfdestruct function is a special feature primarily used to terminate the operation of a contract under certain circumstances and release related resources.

The main purpose of the selfdestruct function is to allow contract creators to destroy a deployed smart contract. When the selfdestruct function is triggered, the smart contract will be permanently removed, and the remaining Ether stored at the contract is sent to a designated target address. At the same time, all data and functions associated with the contract(the storage and code is removed from the state) will no longer be available. Use cases for the selfdestruct function include abandoning contracts that are no longer in use, upgrading contract versions, or addressing potential security issues.

However, the selfdestruct function may also pose security risks. If the implementation of the selfdestruct function is improper, it could be exploited by malicious users, potentially disrupting the normal operation of the contract or causing asset loss.

What Security Vulnerabilities May Be Caused ?

First, we need to understand the following ways to transfer funds in Solidity:

transfer: Throws exception when an error occurs, and the code will not execute afterward.
send: The transfer error does not throw an exception and returns true/false. The code will continue to execute.
call.value().gas()(): Transfer error does not throw an exception and returns true/false. The code will execute, but call functions for transfer are prone to reentrancy attacks.

All three transfer methods listed above require the target to accept the transfer for the tokens to be successfully transferred to the target address. However, the selfdestruct function can transfer funds without the target's acceptance. It is due to this "forced transfer" characteristic of the selfdestruct function that attackers can exploit it to affect the normal functionality of the target contract. For example, if developers use address(this).balance to extract the token balance in the contract, they may be vulnerable to attack.

Another issue is that if the selfdestruct function in a smart contract does not restrict who can trigger it, then any malicious user can destroy the contract. This could render the contract unusable and lead to a loss of funds. Additionally, if the selfdestruct function is poorly designed or contains programming errors, it may be triggered unintentionally. This could cause the contract's functionality to be paralyzed and even result in a loss of funds.

Vulnerability Example

Next, we will present a contract vulnerability case to help you better understand how attackers can exploit the selfdestruct function to attack the target contract:

        
        // SPDX-License-Identifier: MIT
        pragma solidity ^0.8.10;

        contract EtherGame{
            uint public targetAmount = 7 ether;
            address public winner;

            function deposit() public payable{
                requir(msg.value == 1 ether,"You can only send 1 Ether");

                unit balance = address(this).balance;
                require(balance <= targetAmount, "Game is over");

                if (balance == targetAmount){
                    winner - msg.sender;
                }
            }

            function claimReward() public {
                require(msg.sender == winner, "Not winner");
                (bool sent,) = msg.sender.call{value:address(this).balance}("");
                require(sent, "Failed to send Ether");
            }
        }

Vulnerability Analysis

The EtherGame contract is designed as a game. Players send 1 Ether to the contract each time, once the balance reaches seven Ether, the player who placed the last Ether is declared the winner and can withdraw all funds in the contract.

The players call the EtherGame.deposit function to send 1 Ether to the contract. The function will checks whether the contract's balance is less than or equal to 7. The contract will continue to execute only if the balance is less than or equal to 7, otherwise it will revert. The balance in the contract is obtained through address(this).balance. As long as we forcibly send Ether to the contract before a winner is generated, making the contract's balance greater than or equal to 7, we can paralyze the EtherGame contract, making it impossible to produce a winner.

Since there is a validation in the EtherGame.deposit function, only 1 Ether can be sent each time, so it is impossible to send more than 1 Ether to the contract through the normal path. Therefore, the selfdestruct function is needed. The attacker can create an attack contract and then trigger the selfdestruct function to destroy the contract. The Ether balance in the attack contract will automatically be sent to the EtherGame contract. In this way, multiple Ethers can be sent at once, making the EtherGame contract's balance greater than or equal to 7, thereby paralyzing the contract.

How To Prevent Selfdestruct Function Vulnerabilities?