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

Integer overflow on `PuppyRaffle::totalFees` causes loss of protocol fees

fyuryy

Integer overflow on PuppyRaffle::totalFees causes loss of protocol fees

Description

The totalFees variable is declared as uint64, which has a maximum value of 18446744073709551615 (~18.4 ETH). The fee calculated in selectWinner is a uint256 that is downcasted to uint64 before being added to totalFees. When the accumulated fees exceed the uint64 max value, the addition silently overflows (Solidity ^0.7.6 does not have built-in overflow checks), wrapping around to a much smaller value.

This means the protocol permanently loses track of collected fees.

// totalFees is declared as uint64
@> uint64 public totalFees = 0;
function selectWinner() external {
// ...
uint256 totalAmountCollected = players.length * entranceFee;
uint256 prizePool = (totalAmountCollected * 80) / 100;
uint256 fee = (totalAmountCollected * 20) / 100;
@> totalFees = totalFees + uint64(fee);
// ...
}

Risk

Likelihood:

  • This will occur once cumulative fees across multiple raffle rounds exceed ~18.4 ETH -- a realistic amount for any moderately popular raffle

  • The contract uses Solidity ^0.7.6, which has no built-in overflow protection

Impact:

  • The totalFees variable wraps around, recording a value far lower than the actual fees collected

  • The withdrawFees function relies on address(this).balance == uint256(totalFees), which will fail or allow withdrawal of only the overflowed (smaller) amount

  • Protocol fees are permanently lost and locked in the contract

Proof of Concept

  1. The uint64 max value is 18446744073709551615, which is approximately 18.4 ETH.

  2. Each raffle round with 4 players at 1 ETH entrance fee collects 4 * 1e18 * 20 / 100 = 0.8 ETH in fees.

  3. We simulate 93 consecutive raffle rounds. After 93 rounds, the cumulative expected fees are 93 * 0.8 = 74.4 ETH, which far exceeds the uint64 max of ~18.4 ETH.

  4. In each round, we create 4 new unique players, enter them into the raffle, warp time forward, and call selectWinner. We also track the expected cumulative fees in a uint256 variable.

  5. After all 93 rounds, we compare puppyRaffle.totalFees() (the on-chain uint64 value) against our expected uint256 total.

  6. The assertion puppyRaffle.totalFees() < totalFeesExpected passes, proving that totalFees has silently overflowed and wrapped around to a much smaller value. The protocol has lost track of the majority of its collected fees.

function testOverflowFees() public {
// We need enough players so that fees overflow uint64
// uint64 max = 18446744073709551615 (~18.4 ether)
// Each round with 4 players at 1 ether entrance fee = 0.8 ether in fees
// 93 rounds * 0.8 ether = 74.4 ether > 18.4 ether, guaranteeing overflow
uint256 totalFeesExpected = 0;
for (uint256 round = 0; round < 93; round++) {
address[] memory players = new address[](4);
for (uint256 i = 0; i < 4; i++) {
players[i] = address(uint160(round * 4 + i + 100));
}
puppyRaffle.enterRaffle{value: entranceFee * 4}(players);
vm.warp(block.timestamp + duration + 1);
vm.roll(block.number + 1);
puppyRaffle.selectWinner();
totalFeesExpected += (entranceFee * 4 * 20) / 100;
}
console.log("Expected totalFees: ", totalFeesExpected);
console.log("Actual totalFees: ", puppyRaffle.totalFees());
// totalFees has overflowed and is less than the expected value
assert(puppyRaffle.totalFees() < totalFeesExpected);
}

Recommended Mitigation

Change totalFees to uint256 to prevent overflow, or use a newer Solidity version (>=0.8.0) with built-in overflow checks:

- 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 1 day 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!