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

uint64 overflow in PuppyRaffle::selectWinner() permanently locks all protocol fees

georgibuilds

Root + Impact

Description

  • PuppyRaffle::selectWinner() accumulates protocol fees in totalFees declared as uint64. The maximum value of uint64 is ~18.44 ETH. After enough raffle rounds, totalFees silently overflows and wraps back to near zero, permanently making withdrawFees() unsatisfiable and locking all accumulated fees inside the contract forever.

// @> uint64 max = 18,446,744,073,709,551,615 (~18.44 ETH in wei)
uint64 public totalFees = 0;
​
function selectWinner() external {
...
uint256 fee = (totalAmountCollected * 20) / 100;
// @> Silent overflow when totalFees exceeds uint64 max
totalFees = totalFees + uint64(fee);
...
}

Risk

Likelihood:

  • Occurs naturally after ~23 rounds with 4 players at 1 ETH

  • No attacker action required — normal protocol usage triggers it

  • Scales faster with more players per round

Impact:

  • All accumulated protocol fees permanently locked

  • Owner can never call withdrawFees() successfully

  • ~18.44 ETH lost per overflow cycle

  • No recovery path exists

Proof of Concept

Attack Path: 1. Protocol operates normally — players enter, winners are selected, fees accumulate 2. After ~23 rounds with 4 players at 1 ETH, totalFees exceeds uint64 max (~18.44 ETH) 3. totalFees silently wraps back to near zero 4. withdrawFees() require checks: address(this).balance == uint256(totalFees) Real balance: ~18.44 ETH totalFees: ~0.75 ETH (wrapped) Equality fails → always reverts 5. Owner can never withdraw fees again 6. All accumulated fees permanently locked

function test_overflow() public {
address[] memory players = new address[](4);
for (uint256 i = 0; i < 4; i++) {
players[i] = address(uint160(i + 1));
}
vm.deal(players[0], entranceFee * 4);
vm.prank(players[0]);
puppyRaffle.enterRaffle{value: entranceFee * 4}(players);
​
vm.warp(block.timestamp + raffleDuration + 1);
puppyRaffle.selectWinner();
​
uint64 totalFeesAfterFirstRound = puppyRaffle.totalFees();
console.log("Total fees after round 1:", uint256(totalFeesAfterFirstRound));
​
for (uint256 idx = 0; idx < 23; idx++) {
address[] memory newPlayers = new address[](4);
for (uint256 j = 0; j < 4; j++) {
newPlayers[j] = address(uint160(j + 100 + (idx * 4)));
}
vm.deal(newPlayers[0], entranceFee * 4);
vm.prank(newPlayers[0]);
puppyRaffle.enterRaffle{value: entranceFee * 4}(newPlayers);
vm.warp(block.timestamp + raffleDuration + 1);
puppyRaffle.selectWinner();
}
​
uint64 totalFeesAfterAllRounds = puppyRaffle.totalFees();
console.log("Total fees after 24 rounds:", uint256(totalFeesAfterAllRounds));
assertLt(uint256(totalFeesAfterAllRounds), uint256(totalFeesAfterFirstRound));
}

Recommended Mitigation

Replace uint64 with uint256 for totalFees. Solidity 0.8+ reverts on overflow by default, but this contract uses 0.7.6 where overflow wraps silently. Changing the type eliminates the overflow entirely — uint256 can hold far more ETH than will ever exist.

- 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 9 days 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!