Add a function to claim rewards for specific tokens

Oct 13, 2025 by pynkocean.com 73 views

Digital Mocha Owl - [Medium] Admin Can Cause Users to Lose Accrued Rewards During Token De-Whitelisting

Introduction

In the world of decentralized finance (DeFi), token whitelisting is a crucial mechanism for ensuring the security and integrity of smart contracts. However, a recent vulnerability in the SymmStaking contract has been discovered, which can cause users to lose accrued rewards during token de-whitelisting. In this article, we will delve into the root cause of this vulnerability, its impact, and the mitigation strategies to prevent it.

Summary

The removal of tokens from the rewards list without distributing accumulated rewards will cause a complete loss of accrued rewards for stakers as an admin will de-whitelist a reward token before users can claim their corresponding rewards.

Root Cause

The root cause of this vulnerability lies in the configureRewardToken function in the SymmStaking contract. This function removes tokens from the rewardTokens array when de-whitelisting them (setting status to false), but fails to distribute any accumulated rewards to users before the removal. Since reward claiming depends on iterating through this array, once a token is removed, its accumulated rewards become permanently inaccessible to users.

function configureRewardToken(address token, bool status) external onlyRole(REWARD_MANAGER_ROLE) {
    // ...
    if (!status) {
        // Only remove from the array after ensuring all rewards are distributed
        uint256 len = rewardTokens.length;
        for (uint256 i = 0; i < len; i++) {
            if (rewardTokens[i] == token) {
                rewardTokens[i] = rewardTokens[rewardTokens.length - 1];
                rewardTokens.pop();
                break;
            }
        }
    }
    // ...
}

Internal Pre-conditions

To exploit this vulnerability, the following internal pre-conditions must be met:

Admin needs to whitelist a reward token by calling configureRewardToken(token, true) to add the token to the rewardTokens array
Users need to stake tokens via deposit() to accumulate rewards for the whitelisted token
pendingRewards[token] needs to be at most 10 (a small amount) to allow de-whitelisting
Users need to have unclaimed rewards for the token (rewards[user][token] > 0)

External Pre-conditions

No external pre-conditions are required to exploit this vulnerability, as it relates entirely to the internal functioning of the contract.

Attack Path

The attack path involves the following steps:

Admin whitelists a reward token by calling configureRewardToken(token, true)
Admin or reward manager notifies rewards by calling notifyRewardAmount([token], [amount])
Users deposit tokens into the contract and earn rewards for the whitelisted token
Before users claim their rewards, admin calls configureRewardToken(token, false) to de-whitelist the token
The token is removed from the rewardTokens array because pendingRewards[token] <= 10
Users attempt to claim their rewards by calling claimRewards()
The _claimRewardsFor function only iterates over tokens in the rewardTokens array, completely skipping the de-whitelisted token
User rewards for that token remain trapped in the contract and are never distributed

Impact

Stakers suffer a complete loss of their accrued rewards for the de-whitelisted token. The rewards remain locked in the contract with no mechanism to distribute them once the token is removed from the rewardTokens array. The total loss is equal to the sum of all unclaimed rewards for the de-whitelisted token across all users.

PoC

A proof-of-concept (PoC) code is provided to demonstrate the vulnerability:

contract SymmStakingTest is Test {
    // ...
    
    function testRewardLossOnDeWhitelisting() public {
        // 1. Whitelist the reward token
        stakingContract.configureRewardToken(address(rewardToken), true);
        
        // 2. Users stake tokens
        vm.startPrank(alice);
        stakingContract.deposit(500 * 10**18, alice);
        vm.stopPrank();
        
        vm.startPrank(bob);
        stakingContract.deposit(500 * 10**18, bob);
        vm.stopPrank();
        
        // 3. Notify rewards
        address[] memory tokens = new address[](1);
        tokens[0] = address(rewardToken);
        
        uint256[] memory amounts = new uint256[](1);
        amounts[0] = 100 * 10**18;
        
        stakingContract.notifyRewardAmount(tokens, amounts);
        
        // 4. Fast forward time to accumulate rewards
        vm.warp(block.timestamp + 3 days);
        
        // 5. Calculate Alice's earned rewards before de-whitelisting
        uint256 aliceRewardsBefore = stakingContract.earned(alice, address(rewardToken));
        console.log("Alice's rewards before de-whitelisting:", aliceRewardsBefore);
        
        // Verify rewards are being earned
        assertGt(aliceRewardsBefore, 0, "Alice should have earned rewards");
        
        // 6. Bob claims his rewards
        vm.startPrank(bob);
        stakingContract.claimRewards();
        vm.stopPrank();
        
        // 7. Reduce pending rewards to allow de-whitelisting
        // (This simulates most rewards being claimed, with just Alice's rewards remaining)
        vm.startPrank(admin);
        stakingContract.rescueTokens(address(rewardToken), 10, admin); // Extract most tokens to reduce pendingRewards
        vm.stopPrank();
        
        // 8. De-whitelist the reward token
        vm.startPrank(admin);
        stakingContract.configureRewardToken(address(rewardToken), false);
        vm.stopPrank();
        
        // 9. Alice tries to claim her rewards
        vm.startPrank(alice);
        stakingContract.claimRewards();
        vm.stopPrank();
        
        // 10. Check if Alice received her rewards
        uint256 aliceRewardBalance = rewardToken.balanceOf(alice);
        console.log("Alice's reward token balance after claiming:", aliceRewardBalance);
        
        // This should fail, demonstrating the vulnerability
        assertEq(aliceRewardBalance, 0, "Alice did not receive her rewards after token was de-whitelisted");
        
        // 11. Verify rewards are still tracked in the contract but inaccessible
        uint256 aliceRewardsAfter = stakingContract.rewards(alice, address(rewardToken));
        console.log("Alice's rewards still trapped in contract:", aliceRewardsAfter);
        assertGt(aliceRewardsAfter, 0, "Alice's rewards are still trapped in the contract");
    }
}

Mitigation

To fix this vulnerability, implement one of the following solutions:

Modify the configureRewardToken function: Force a payout of all rewards for the token being de-whitelisted by modifying the configureRewardToken function to handle all outstanding rewards first.

function configureRewardToken(address token, bool status) external onlyRole(REWARD_MANAGER_ROLE) { // ... if (!status && isRewardToken[token]) { if (pendingRewards[token] > 10) revert OngoingRewardPeriodForToken(token, pendingRewards[token]);

    // Force distribution of all remaining rewards for this token
    // This would require tracking all stakers, which is not currently implemented
    // Alternatively, maintain the token in the list but prevent new rewards
}
// ...

}


2.  **Add a function to claim rewards for specific tokens**: Introduce a new function `claimSpecificTokenRewards` that allows users to claim rewards for specific tokens, even if they are no longer in the `rewardTokens` array.

    ```solidity
function claimSpecificTokenRewards(address token) external nonReentrant whenNotPaused {
    // ...
}

By implementing one of these mitigation strategies, you can prevent users from losing accrued rewards during token de-whitelisting and ensure the security and integrity of your smart contract.
Digital Mocha Owl - [Medium] Admin Can Cause Users to Lose Accrued Rewards During Token De-Whitelisting: Q&A

Introduction

In our previous article, we discussed a critical vulnerability in the SymmStaking contract that can cause users to lose accrued rewards during token de-whitelisting. In this Q&A article, we will address some of the most frequently asked questions related to this vulnerability and provide additional insights to help you better understand the issue.

Q: What is the root cause of this vulnerability?

A: The root cause of this vulnerability lies in the configureRewardToken function in the SymmStaking contract. This function removes tokens from the rewardTokens array when de-whitelisting them (setting status to false), but fails to distribute any accumulated rewards to users before the removal.

Q: What are the internal pre-conditions required to exploit this vulnerability?

A: To exploit this vulnerability, the following internal pre-conditions must be met:

Admin needs to whitelist a reward token by calling configureRewardToken(token, true) to add the token to the rewardTokens array
Users need to stake tokens via deposit() to accumulate rewards for the whitelisted token
pendingRewards[token] needs to be at most 10 (a small amount) to allow de-whitelisting
Users need to have unclaimed rewards for the token (rewards[user][token] > 0)

Q: What is the impact of this vulnerability?

A: Stakers suffer a complete loss of their accrued rewards for the de-whitelisted token. The rewards remain locked in the contract with no mechanism to distribute them once the token is removed from the rewardTokens array. The total loss is equal to the sum of all unclaimed rewards for the de-whitelisted token across all users.

Q: Can this vulnerability be exploited by anyone?

A: No, this vulnerability can only be exploited by an admin or a reward manager who has the necessary permissions to de-whitelist tokens.

Q: How can this vulnerability be mitigated?

A: To fix this vulnerability, implement one of the following solutions:

Modify the configureRewardToken function: Force a payout of all rewards for the token being de-whitelisted by modifying the configureRewardToken function to handle all outstanding rewards first.
Add a function to claim rewards for specific tokens: Introduce a new function claimSpecificTokenRewards that allows users to claim rewards for specific tokens, even if they are no longer in the rewardTokens array.

Q: What are the best practices to prevent similar vulnerabilities in the future?

A: To prevent similar vulnerabilities in the future, follow these best practices:

Regularly review and test your smart contract code: Identify potential vulnerabilities and address them before they can be exploited.
Implement robust security measures: Use secure coding practices, such as input validation and error handling, to prevent common attacks.
Monitor your contract's behavior: Keep an eye on your contract's behavior and respond quickly to any unexpected changes.

Q: Where can I find more information about this vulnerability?

A: For more information about this vulnerability, refer to the following resources:

SymmStaking contract code: Review the SymmStaking contract code to understand the vulnerability and its mitigation.
Smart contract security guides: Consult smart contract security guides, such as the OpenZeppelin Security Guide, to learn more about secure coding practices and vulnerability mitigation.
Blockchain security communities: Join blockchain security communities, such as the Ethereum Security Community, to stay up-to-date on the latest security research and best practices.

By following these best practices and staying informed about smart contract security, you can help prevent similar vulnerabilities in the future and ensure the security and integrity of your smart contract.