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

Fee accounting overflows at uint64

joshuapaul1

Root + Impact

Description

  • totalFees is a uint64, used to store cumulative fees

  • since solidity 0.7 does not provide checked arithmetic. Once cumulative fees exceed 2^64 - 1, the value wraps. The contract balance retains the real amount, while totalFees contains the wrapped value, so the strict equality check in withdrawFees fails and fees become stuck.

//@> line 134
function selectWinner() external {
require(block.timestamp >= raffleStartTime + raffleDuration, "PuppyRaffle: Raffle not over");
require(players.length >= 4, "PuppyRaffle: Need at least 4 players");
uint256 winnerIndex =
uint256(keccak256(abi.encodePacked(msg.sender, block.timestamp, block.difficulty))) % players.length;
address winner = players[winnerIndex];
uint256 totalAmountCollected = players.length * entranceFee;
uint256 prizePool = (totalAmountCollected * 80) / 100;
uint256 fee = (totalAmountCollected * 20) / 100;
//this line
totalFees = totalFees + uint64(fee);
​
uint256 tokenId = totalSupply();
​
​

Risk

Likelihood:

  • High. the total fees can exceed 2^64 - 1, when enough players enter the raffle and winner is selected using the selectWinner() function


Impact:

  • High. fees become stuck .

  • After the totalFees exceed 2^64 - 1 the contract balance retains the real amount, while totalFees contains the wrapped value, so the strict equality check in withdrawFees fails and fees become stuck.


Proof of Concept

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
​
import {Test} from "forge-std/Test.sol";
import {PuppyRaffle} from "../src/PuppyRaffle.sol";
​
contract PuppyRaffleFeeOverflowTest is Test {
uint256 private constant ENTRANCE\_FEE = 1 ether;
uint256 private constant RAFFLE\_DURATION = 1 days;
uint256 private constant ROUNDS = 24;
​
​
​
​
PuppyRaffle private raffle;
​
address private playerOne = address(0x1001);
address private playerTwo = address(0x1002);
address private playerThree = address(0x1003);
address private playerFour = address(0x1004);
​
function setUp() public {
raffle = new PuppyRaffle(
ENTRANCE_FEE,
address(0x99),
RAFFLE_DURATION
);
​
// Funds the test contract for 24 rounds of four 1 ETH entries.
vm.deal(address(this), 100 ether);
}
​
function test_TotalFeesOverflowLocksFeeWithdrawal() public {
for (uint256 i = 0; i < ROUNDS; i++) {
address[] memory entrants = new address[](4);
entrants[0] = playerOne;
entrants[1] = playerTwo;
entrants[2] = playerThree;
entrants[3] = playerFour;
​
raffle.enterRaffle{value: 4 ether}(entrants);
​
vm.warp(block.timestamp + RAFFLE_DURATION + 1);
vm.roll(block.number + 1);
​
raffle.selectWinner();
}
​
/*
* Per round:
* - 4 ETH collected
* - 3.2 ETH prize paid
* - 0.8 ETH accumulated as fees
*
* After 24 rounds:
* - Actual contract ETH balance: 19.2 ETH
* - totalFees before overflow: 19.2 ETH
*
* uint64 max is approximately 18.4467 ETH in wei. Therefore
* totalFees wraps after the 24th round.
*/
uint256 actualFees = (ROUNDS * 8 ether) / 10; // 19.2 ETH
uint256 uint64Range = uint256(type(uint64).max) + 1;
uint256 wrappedFees = actualFees - uint64Range;
​
assertEq(address(raffle).balance, actualFees);
assertEq(uint256(raffle.totalFees()), wrappedFees);
​
/*
* withdrawFees requires:
*
* address(this).balance == totalFees
*
* But 19.2 ETH != wrappedFees, so the accumulated fees are locked.
*/
vm.expectRevert("PuppyRaffle: There are currently players active!");
raffle.withdrawFees();
}

The vulnerable line is:

totalFees = totalFees + uint64(fee);

totalFees should be a uint256, and the narrowing cast should be removed:

Recommended Mitigation

first, the uint256 should be used instead of uint64 to accomodate larger values

at line 30

contract PuppyRaffle is ERC721, Ownable {
using Address for address payable;
​
uint256 public immutable entranceFee;
​
address[] public players;
uint256 public raffleDuration;
uint256 public raffleStartTime;
address public previousWinner;
​
// We do some storage packing to save gas
address public feeAddress;
-uint64 public totalFees = 0;
+uint256 public totalFees = 0;
...}

and at line 134 the narrowing cast should be removed:

​
function selectWinner() external {
require(block.timestamp >= raffleStartTime + raffleDuration, "PuppyRaffle: Raffle not over");
require(players.length >= 4, "PuppyRaffle: Need at least 4 players");
uint256 winnerIndex =
uint256(keccak256(abi.encodePacked(msg.sender, block.timestamp, block.difficulty))) % players.length;
address winner = players[winnerIndex];
uint256 totalAmountCollected = players.length * entranceFee;
uint256 prizePool = (totalAmountCollected * 80) / 100;
uint256 fee = (totalAmountCollected * 20) / 100;
-totalFees = totalFees + uint64(fee);
+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!