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

Unsafe uint64 cast and overflow of `totalFees` corrupts accounting and permanently locks protocol fees

mohdhuzaifah0786

Root + Impact

Description

  • Normal behavior: Each draw adds 20% of the round's proceeds to totalFees, and withdrawFees() later sends exactly that amount to the feeAddress.

  • Specific issue: The contract compiles with Solidity 0.7.6, which has no built-in overflow protection. fee is a uint256 but is force-cast to uint64 before being added to the uint64 totalFees. When a round's fee exceeds type(uint64).max (~18.44 ETH) the cast truncates, and when cumulative fees exceed type(uint64).max the addition silently wraps. totalFees then no longer equals the ETH actually held, and withdrawFees()'s strict equality check can never pass again.

// Root cause in the codebase with @> marks to highlight the relevant sectionsolidity
@> uint64 public totalFees = 0;
...
uint256 fee = (totalAmountCollected * 20) / 100; // uint256, can exceed uint64 max
@> totalFees = totalFees + uint64(fee); // truncating cast + wrapping add (no 0.8 check)
...
function withdrawFees() external {
@> require(address(this).balance == uint256(totalFees), "PuppyRaffle: There are currently players active!");

Risk

Likelihood:

  • Reason 1: Occurs when cumulative undrawn fees exceed type(uint64).max (~18.44 ETH), which is reached naturally over multiple well-attended rounds before a withdrawal.

  • Reason 2: Occurs in a single round whenever totalAmountCollected exceeds ~92 ETH (e.g. a large entranceFee or many players), truncating the uint64(fee) cast.

Impact:

  • Impact 1: totalFees diverges from the real ETH balance, so withdrawFees() reverts forever and all accumulated protocol fees are permanently locked.

  • Impact 2: Fee accounting is corrupted, under-recording amounts owed to the feeAddress and breaking every downstream assumption about protocol revenue.

Proof of Concept

Add to test/PuppyRaffleTest.t.sol and run forge test --mt test_totalFees_overflow -vvv.
​
solidity
function test_totalFees_overflow() public {
// ---- Round 1: 4 players -> totalFees = 0.8 ETH ----
address[] memory playersOne = new address[](4);
for (uint160 i = 0; i < 4; i++) playersOne[i] = address(i + 1);
puppyRaffle.enterRaffle{value: entranceFee * 4}(playersOne);
vm.warp(block.timestamp + duration + 1);
vm.roll(block.number + 1);
puppyRaffle.selectWinner();
​
uint256 startingTotalFees = puppyRaffle.totalFees();
console.log("totalFees after round 1:", startingTotalFees); // 800000000000000000
​
// ---- Round 2: 89 players -> fee add overflows uint64 ----
uint256 playersNum = 89;
address[] memory playersTwo = new address[](playersNum);
for (uint160 i = 0; i < playersNum; i++) playersTwo[i] = address(i + 5);
puppyRaffle.enterRaffle{value: entranceFee * playersNum}(playersTwo);
vm.warp(block.timestamp + duration + 1);
vm.roll(block.number + 1);
puppyRaffle.selectWinner();
​
uint256 endingTotalFees = puppyRaffle.totalFees();
console.log("totalFees after round 2:", endingTotalFees);
​
// Fees went DOWN despite more fees being earned -> overflow/truncation
assert(endingTotalFees < startingTotalFees);
​
// And withdrawal is now permanently bricked
vm.expectRevert("PuppyRaffle: There are currently players active!");
puppyRaffle.withdrawFees();
}

Recommended Mitigation

Upgrade to a Solidity 0.8.x compiler (built-in overflow checks) and store fees as uint256, removing the truncating cast.
​
- pragma solidity ^0.7.6;
+ pragma solidity 0.8.20;
...
- uint64 public totalFees = 0;
+ uint256 public totalFees = 0;
...
- totalFees = totalFees + uint64(fee);
+ totalFees = totalFees + fee;
Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 5 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!