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

Unsafe uint64 cast on totalFees causes overflow, permanently locking protocol fees

phylax

Unsafe uint64 cast on totalFees causes overflow, permanently locking protocol fees

Description

  • The contract calculates a 20% fee to the protocol owner and stores the balance in the totalFeesstate variable, which is then read when the withdrawFeesfunction is called.

  • The Solidity version is < 0.8.0which does not have built in arithmic overflow/underflow control and the state variable is cast as a uint64, so if the totalFeesbecomes too large it creates integer overflow which wraps around making the variable much smaller than the original fees. This locks the remaining fees in the protocol and are unretrivable.

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;
// rest of code

Risk

Likelihood:

  • Any raffle with enough players paying a sufficiently large entranceFeewill inevitably trigger the overflow, and since Solidity 0.7.xhas no built in overflow protection, it happens silently with no indication anything went wrong.

Impact:

  • Once overflowed, totalFeesreports falsely small value, causing the withdrawFeesfunction to send the feeAddressa fraction of what its owed, with the remaining ETH locked in the contract.

Proof of Concept

  1. 100 players enters the raffle paying 1 ETH each.

  2. Fees are the 20% of 100 ETH which is 20 ETH.

  3. uint64max is ~18.5 ETH so the fees are ~1.5 ETH more than the max uint64, wrapping around making totalFees= 1.5 ETH.

  4. When withdrawFeesis called the contract only send 1.5 ETH to the `feeAddress`, with the remaining 18.5 ETH locked in contract.

function testArithmeticOverflow() public {
// Players enter the raffle
address[] memory players = new address[](100);
for (uint256 i = 0; i < players.length; i++) {
players[i] = makeAddr(string(abi.encodePacked("player", vm.toString(i))));
vm.deal(players[i], initialBalance);
}
​
uint256 totalEntranceFee = entranceFee * players.length;
​
raffle.enterRaffle{value: totalEntranceFee}(players);
​
uint256 totalFeesBeforeOverflow = raffle.totalFees();
​
// Calculate expected fee (20% of total)
uint256 expectedFee = (totalEntranceFee * 20) / 100; // 20 ether = 2e19 wei
uint256 maxUint64 = type(uint64).max; // ~1.8e19 wei
​
// Move forward in time to allow selectWinner
vm.warp(block.timestamp + 1 days);
​
// Call selectWinner - this should NOT revert in Solidity < 0.8
// Instead, the arithmetic overflow should wrap around silently
raffle.selectWinner();
​
uint256 totalFeesAfterOverflow = raffle.totalFees();
​
// The wrapped value should be: expectedFee - (maxUint64 + 1)
uint256 expectedWrappedValue = expectedFee - (maxUint64 + 1);
​
// In Solidity < 0.8, the value should wrap around, not revert
// So the totalFees becomes 1.553e18 because the fees collected are 20e18 and the type(uint64).max is ~1.8e19, so the wrapped value is 20e18 - (1.8e19 + 1) = 1.553e18
assertEq(totalFeesAfterOverflow, expectedWrappedValue);
​
// This demonstrates the vulnerability: fees are much smaller than expected
assert(totalFeesAfterOverflow < expectedFee);
}

Recommended Mitigation

Cast the totalFeesas a uint256so the max integer is large enough to handle any large fee balance.

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;
​
Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 8 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!