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

totalFees uint64 overflow in Solidity 0.7.6 corrupts fee accounting and locks withdrawFees

soles

Root + Impact

Description

selectWinner accumulates the protocol's 20% cut into `totalFees` after each raffle, and withdrawFees later pays that amount to the feeAddress. The problem is that `totalFees` is a uint64 (max ~18.44 ether in wei) and the contract compiles with Solidity 0.7.6, which does NOT revert on arithmetic overflow. When accumulated fees exceed the uint64 maximum, `totalFees` silently wraps around to a much smaller value. Additionally, `uint64(fee)` truncates if `fee` exceeds the uint64 range. The recorded fee then no longer matches the ETH actually held by the contract.

uint64 public totalFees = 0;
...
uint256 fee = (totalAmountCollected * 20) / 100;
totalFees = totalFees + uint64(fee); // @> uint64 overflow (no revert in 0.7.6) + truncating cast

Risk

Likelihood:

  • Occurs whenever accumulated fees exceed ~18.44 ether: a single 100-player raffle at 1 ether entry produces a 20 ether fee, already over the uint64 max.

  • Also occurs gradually as fees accumulate across multiple raffles.

Impact:

  • totalFees is recorded as far less than the ETH actually collected, corrupting the protocol's fee accounting.

  • withdrawFees requires address(this).balance == uint256(totalFees), which no longer holds after the wrap, so legitimate fees can become permanently unwithdrawable.

Proof of Concept

A 100-player raffle produces a real fee of 20 ether, but totalFees (uint64, max ~18.44 ether) wraps to ~1.56 ether. The recorded value is far below the actual fee collected.

function test_PoC_FeeOverflow() public {
// 100 players at 1 ether -> total 100 ether, fee = 20 ether
// ...enter raffle, warp past duration...
uint256 expectedFee = (100 * 1 ether * 20) / 100; // 20 ether
puppyRaffle.selectWinner();
uint256 recordedFees = uint256(puppyRaffle.totalFees());
assertLt(recordedFees, expectedFee); // recorded ~1.56 ether << 20 ether real
}

Recommended Mitigation

Use uint256 for totalFees to eliminate both the overflow and the truncating cast. Additionally, consider upgrading to Solidity 0.8+ where arithmetic overflow reverts by default, or use SafeMath in 0.7.6.

- 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 3 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!