Puppy Raffle
AI First Flight #1
Beginner FriendlyFoundrySolidityNFT
EXP
View results
Previous Next
Submission Details
Severity: high
Valid

`uint64` fee accounting can overflow and permanently lock fees

hongphat19

Root + Impact

Description

After each raffle, the protocol should account for 20% of the collected funds as fees and allow those fees to be withdrawn to feeAddress.

totalFees is stored as uint64, but fees are denominated in wei. uint64 can store only about 18.44 ether. In Solidity 0.7.6, integer casts and additions do not provide the same automatic overflow protection as Solidity 0.8+. When the fee amount exceeds the uint64 range, uint64(fee) truncates the value and records the wrong fee amount.

// @> Too small for wei-denominated ETH accounting.
uint64 public totalFees = 0;
​
function selectWinner() external {
...
uint256 fee = (totalAmountCollected * 20) / 100;
​
// @> fee is cast from uint256 to uint64 and can truncate.
totalFees = totalFees + uint64(fee);
...
}
​
function withdrawFees() external {
// @> This equality can never pass once totalFees is corrupted.
require(address(this).balance == uint256(totalFees), "PuppyRaffle: There are currently players active!");
...
}

Risk

Likelihood:

  • Raffles collect ETH in wei, while uint64 has a low maximum for ETH-denominated accounting.

  • A raffle with more than about 92.23 ether total collected creates a fee greater than type(uint64).max.

Impact:

  • totalFees becomes smaller than the actual ETH fee balance.

  • withdrawFees can permanently revert, locking protocol fees in the contract.

Proof of Concept

With an entrance fee of 1 ether, 93 players produce an 18.6 ether fee, which exceeds type(uint64).max.

function testTotalFeesOverflowLocksFees() public {
address[] memory players = new address[](93);
for (uint160 i = 0; i < 93; i++) {
players[i] = address(i + 1);
}
​
puppyRaffle.enterRaffle{value: entranceFee * 93}(players);
​
vm.warp(block.timestamp + duration + 1);
vm.roll(block.number + 1);
puppyRaffle.selectWinner();
​
uint256 expectedFee = (entranceFee * 93 * 20) / 100;
assertEq(address(puppyRaffle).balance, expectedFee);
assertLt(puppyRaffle.totalFees(), expectedFee);
​
vm.expectRevert("PuppyRaffle: There are currently players active!");
puppyRaffle.withdrawFees();
}

The balance contains the real fee amount, but totalFees holds a truncated value, so the strict equality check fails.

Recommended Mitigation

Use uint256 for wei-denominated accounting and use SafeMath for Solidity 0.7.6.

- uint64 public totalFees = 0;
+ uint256 public totalFees = 0;
​
function selectWinner() external {
...
uint256 fee = (totalAmountCollected * 20) / 100;
- totalFees = totalFees + uint64(fee);
+ totalFees = totalFees + fee;
...
}
​
Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 2 hours ago
Submission Judgement Published
Validated
Assigned finding tags:

[H-05] Typecasting from uint256 to uint64 in PuppyRaffle.selectWinner() May Lead to Overflow and Incorrect Fee Calculation

## Description ## Vulnerability Details The type conversion from uint256 to uint64 in the expression 'totalFees = totalFees + uint64(fee)' may potentially cause overflow problems if the 'fee' exceeds the maximum value that a uint64 can accommodate (2^64 - 1). ```javascript totalFees = totalFees + uint64(fee); ``` ## POC <details> <summary>Code</summary> ```javascript function testOverflow() public { uint256 initialBalance = address(puppyRaffle).balance; // This value is greater than the maximum value a uint64 can hold uint256 fee = 2**64; // Send ether to the contract (bool success, ) = address(puppyRaffle).call{value: fee}(""); assertTrue(success); uint256 finalBalance = address(puppyRaffle).balance; // Check if the contract's balance increased by the expected amount assertEq(finalBalance, initialBalance + fee); } ``` </details> In this test, assertTrue(success) checks if the ether was successfully sent to the contract, and assertEq(finalBalance, initialBalance + fee) checks if the contract's balance increased by the expected amount. If the balance didn't increase as expected, it could indicate an overflow. ## Impact This could consequently lead to inaccuracies in the computation of 'totalFees'. ## Recommendations To resolve this issue, you should change the data type of `totalFees` from `uint64` to `uint256`. This will prevent any potential overflow issues, as `uint256` can accommodate much larger numbers than `uint64`. Here's how you can do it: Change the declaration of `totalFees` from: ```javascript uint64 public totalFees = 0; ``` to: ```jasvascript uint256 public totalFees = 0; ``` And update the line where `totalFees` is updated from: ```diff - totalFees = totalFees + uint64(fee); + totalFees = totalFees + fee; ``` This way, you ensure that the data types are consistent and can handle the range of values that your contract may encounter.

Support

FAQs

Can't find an answer? Chat with us on Discord, Twitter or Linkedin.

Give us feedback!