Puppy Raffle

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

[M] totalFees is stored as UINT64. If the value of entranceFee is too large, a smaller number of users can cause totalFees to overflow, resulting in loss of funds.

Root + Impact

Description

  • Users participate in the raffle; winners receive their entitled prizes, and the prize amounts will not be miscalculated.

  • When the value of fee exceeds type(uint64).max, using uint64(fee) will truncate the higher bits, causing the fee to decrease, resulting in a loss.

  • type(uint64).max can represent up to 18.5 ETH; if entranceFee == 1 ETH, then with roughly 93 participants the fee will begin to decrease.

// Root cause in the codebase with @> marks to highlight the relevant section
function selectWinner() external {
// ...
uint256 fee = (totalAmountCollected * 20) / 100;
totalFees = totalFees + uint64(fee); //@> The `uint64(fee)` value may be truncated, resulting in a decrease in value.
//...
}

Risk

Likelihood:

  • After calculation, when entranceFee is set to 1 ETH, only 93 participants are needed for uint64(fee) to be truncated and its value reduced. Therefore, the larger the entranceFee is set, the fewer participants are required for uint64(fee) to overflow, causing a loss of funds.


Impact:

  • The totalFees amount decreases, the funds will be permanently locked in the contract.

  • address(this).balance and uint256(totalFees) are unlikely to be equal

Proof of Concept

  1. entranceFeeequal 1e18.

  2. Initialize 100 players.

  3. selectWinner()

  4. Compare Expected Total Fees and Actual Total Fees.

  5. withdrawFees()

  6. expectRevert


    function test_Poc_TotalFeesOverflow() public {
    // 1. Simulate 100 players entering the raffle, each paying entranceFee
    address[] memory players = new address[](100);
    for (uint256 i = 0; i < 100; i++) {
    players[i] = address(i + 1);
    }
    puppyRaffle.enterRaffle{value: entranceFee * 100}(players);
    // 2. Time passes, raffle ends
    vm.warp(block.timestamp + duration + 1);
    vm.roll(block.number + 1);
    // 3. Select a winner, triggering totalFees update
    puppyRaffle.selectWinner();
    // 4. Check whether totalFees overflows
    uint256 expectedTotalFees = (entranceFee * 100 * 20) / 100;
    console.log("Expected total fees: ", uint256(expectedTotalFees));
    console.log("Actual total fees: ", uint256(puppyRaffle.totalFees()));
    console.log("Actual balance: ", address(puppyRaffle).balance);
    assertLt(puppyRaffle.totalFees(), uint256(expectedTotalFees));
    vm.expectRevert("PuppyRaffle: There are currently players active!");
    puppyRaffle.withdrawFees();
    }
[PASS] test_Poc_TotalFeesOverflow() (gas: 5421895)
Logs:
Expected total fees: 20000000000000000000
Actual total fees: 1553255926290448384
Actual balance: 20000000000000000000

Recommended Mitigation

  1. Change the type of totalFees to uint256

  2. uint64(fee) => fee


- uint64 public totalFees = 0;
+ uint256 public totalFees = 0;
function selectWinner() external {
- 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!