Snowman Merkle Airdrop
AI First Flight #10
Beginner FriendlyFoundrySolidityNFT
EXP
View results
Previous Next
Submission Details
Severity: low
Valid

Global s_earnTimer updated by buySnow(0): anyone can permanently block all free Snow claims at zero cost

p7inc3

Root + Impact

Normal behavior: earnSnow() lets users claim 1 free Snow per week, gated by s_earnTimer + 1 weeks.

Issue: s_earnTimer is global (one variable for all users) and buySnow() also writes it. Because buySnow accepts amount = 0 (msg.value == s_buyFee * 0 → 0 == 0 → true), anyone can call buySnow{value: 0}(0) — a transaction that mints nothing and costs 0 wei — and push the timer forward. Repeating it once per week (or before every victim attempt) blocks every user's free claim for the entire 12-week FARMING_DURATION. Additionally, since the timer is shared, any single user's claim (or any paid purchase) blocks all other users for a week — the timer is not per-user.

function buySnow(uint256 amount) external payable canFarmSnow {
if (msg.value == (s_buyFee * amount)) { // @> 0 == s_buyFee * 0 → true for amount=0 @>
_mint(msg.sender, amount); // mints 0 tokens
} else {
i_weth.safeTransferFrom(msg.sender, address(this), (s_buyFee * amount));
_mint(msg.sender, amount);
}
​
@> s_earnTimer = block.timestamp; // @> free tx resets the GLOBAL free-claim timer
​
emit SnowBought(msg.sender, amount);
}
​
function earnSnow() external canFarmSnow {
@> if (s_earnTimer != 0 && block.timestamp < (s_earnTimer + 1 weeks)) { // @> blocks ALL users
revert S__Timer();
}

There is no require(amount > 0) and no per-user timer mapping.

Risk

Likelihood:

  • The attack requires a single unprivileged transaction anyone can send — no tokens, no approval, no whitelist entry; the PoC shows the attacker pays 0 wei and receives 0 tokens yet the victim's eligible claim reverts S__Timer.

  • The condition occurs continuously during the protocol's normal operation: s_earnTimer is global, so honest purchases and other users' claims keep resetting it, and an attacker bot repeating buySnow(0) weekly maintains the block for the full FARMING_DURATION (12 weeks).

Impact:

  • Complete denial of the free-earning feature for all users at zero attacker cost — the protocol's "earn Snow weekly for free" mechanism becomes unusable.

  • The shared timer also means one user's action (claim or purchase) blocks every other user's weekly claim in that window — cross-user griefing beyond the attacker case.

Proof of Concept

// forge test --match-test test_F4_zeroCostDoS_ofEarnSnow -vv
function test_F4_zeroCostDoS_ofEarnSnow() public {
MockWETH weth = new MockWETH();
Snow snow = new Snow(address(weth), 5, makeAddr("collector"));
​
(address alice,) = makeAddrAndKey("alice");
(address attacker,) = makeAddrAndKey("attacker");
address bob = makeAddr("bob");
​
// Leg A: global timer — Bob is blocked by ALICE's claim (not his own)
vm.prank(alice);
snow.earnSnow();
vm.prank(bob);
vm.expectRevert(Snow.S__Timer.selector);
snow.earnSnow();
​
// Leg B: attacker pushes timer forward at ZERO cost
vm.warp(block.timestamp + 1 weeks); // Alice is eligible again
​
uint256 atkEthBefore = attacker.balance;
vm.prank(attacker);
snow.buySnow{value: 0}(0); // free tx: mints 0, sets s_earnTimer = now
assertEq(attacker.balance, atkEthBefore, "attacker paid 0 wei");
assertEq(snow.balanceOf(attacker), 0, "attacker received 0 tokens");
​
// Alice's now-eligible weekly claim is DoS'd by the free tx:
vm.prank(alice);
vm.expectRevert(Snow.S__Timer.selector);
snow.earnSnow();
​
// Control: she only succeeds after waiting one EXTRA week
vm.warp(block.timestamp + 1 weeks);
vm.prank(alice);
snow.earnSnow();
assertEq(snow.balanceOf(alice), 2);
// Repeat buySnow(0) every week => earnSnow unusable for everyone, 12 weeks straight.
}

Result: PASS on commit 6efcb0f — attacker spent 0 wei, minted 0 tokens, and delayed every honest user's free claim; repeating weekly keeps the feature disabled for the entire farming period.

Recommended Mitigation

function buySnow(uint256 amount) external payable canFarmSnow {
+ require(amount > 0, "zero amount");
if (msg.value == (s_buyFee * amount)) {
_mint(msg.sender, amount);
} else {
+ require(msg.value == 0, "unexpected ETH");
i_weth.safeTransferFrom(msg.sender, address(this), (s_buyFee * amount));
_mint(msg.sender, amount);
}
-
- s_earnTimer = block.timestamp;
-
emit SnowBought(msg.sender, amount);
}

And make the free-claim timer per user so one address cannot block another:

- uint256 private s_earnTimer;
+ mapping(address => uint256) private s_earnTimer;
​
function earnSnow() external canFarmSnow {
- if (s_earnTimer != 0 && block.timestamp < (s_earnTimer + 1 weeks)) {
+ if (s_earnTimer[msg.sender] != 0 && block.timestamp < (
Updates

Lead Judging Commences

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

[L-02] Global Timer Reset in Snow::buySnow Denies Free Claims for All Users

## Description: The `Snow::buySnow` function contains a critical flaw where it resets a global timer `(s_earnTimer)` to the current block timestamp on every invocation. This timer controls eligibility for free token claims via `Snow::earnSnow()`, which requires 1 week to pass since the last timer reset. As a result: Any token purchase `(via buySnow)` blocks all free claims for all users for 7 days Malicious actors can permanently suppress free claims with micro-transactions Contradicts protocol documentation promising **"free weekly claims per user"** ## Impact: * **Complete Denial-of-Service:** Free claim mechanism becomes unusable * **Broken Protocol Incentives:** Undermines core user acquisition strategy * **Economic Damage:** Eliminates promised free distribution channel * **Reputation Harm:** Users perceive protocol as dishonest ```solidity function buySnow(uint256 amount) external payable canFarmSnow { if (msg.value == (s_buyFee * amount)) { _mint(msg.sender, amount); } else { i_weth.safeTransferFrom(msg.sender, address(this), (s_buyFee * amount)); _mint(msg.sender, amount); } @> s_earnTimer = block.timestamp; emit SnowBought(msg.sender, amount); } ``` ## Risk **Likelihood**: • Triggered by normal protocol usage (any purchase) • Requires only one transaction every 7 days to maintain blockage • Incentivized attack (low-cost disruption) **Impact**: • Permanent suppression of core protocol feature • Loss of user trust and adoption • Violates documented tokenomics ## Proof of Concept **Attack Scenario:** Permanent Free Claim Suppression * Attacker calls **buySnow(1)** with minimum payment * **s\_earnTimer** sets to current timestamp (T0) * All **earnSnow()** calls revert for **next 7 days** * On day 6, attacker repeats **buySnow(1)** * New timer reset (T1 = T0+6 days) * Free claims blocked until **T1+7 days (total 13 days)** * Repeat step **4 every 6 days → permanent blockage** **Test Case:** ```solidity // Day 0: Deploy contract snow = new Snow(...); // s_earnTimer = 0 // UserA claims successfully snow.earnSnow(); // Success (first claim always allowed) // Day 1: UserB buys 1 token snow.buySnow(1); // Resets global timer to day 1 // Day 2: UserA attempts claim snow.earnSnow(); // Reverts! Requires day 1+7 = day 8 // Day 7: UserC buys 1 token (day 7 < day 1+7) snow.buySnow(1); // Resets timer to day 7 // Day 8: UserA retries snow.earnSnow(); // Still reverts! Now requires day 7+7 = day 14 ``` ## Recommended Mitigation **Step 1:** Remove Global Timer Reset from `buySnow` ```diff function buySnow(uint256 amount) external payable canFarmSnow { // ... existing payment logic ... - s_earnTimer = block.timestamp; emit SnowBought(msg.sender, amount); } ``` **Step 2:** Implement Per-User Timer in `earnSnow` ```solidity // Add new state variable mapping(address => uint256) private s_lastClaimTime; function earnSnow() external canFarmSnow { // Check per-user timer instead of global if (s_lastClaimTime[msg.sender] != 0 && block.timestamp < s_lastClaimTime[msg.sender] + 1 weeks ) { revert S__Timer(); } _mint(msg.sender, 1); s_lastClaimTime[msg.sender] = block.timestamp; // Update user-specific timer emit SnowEarned(msg.sender, 1); // Add missing event } ``` **Step 3:** Initialize First Claim (Constructor) ```solidity constructor(...) { // Initialize with current timestamp to prevent immediate claims s_lastClaimTime[address(0)] = block.timestamp; } ```

Support

FAQs

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

Give us feedback!