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

[M-02] Global `s_earnTimer` enables single-caller DoS on free Snow earning for all users

cthan

[M-02] Global s_earnTimer enables single-caller DoS on free Snow earning for all users

Description

Snow.s_earnTimer is declared as a single global uint256 (one storage slot, not per-user), yet consumed as if it were a per-user rate limit:

// src/Snow.sol:30 — single global slot
uint256 private s_earnTimer;
​
// src/Snow.sol:92-99 — earnSnow READS the global, then WRITES it
function earnSnow() external canFarmSnow {
if (s_earnTimer != 0 && block.timestamp < (s_earnTimer + 1 weeks)) {
revert S__Timer();
}
_mint(msg.sender, 1);
s_earnTimer = block.timestamp;
}
​
// src/Snow.sol:79-90 — buySnow ALSO writes the global timer (no rate-limit semantic of its own)
function buySnow(uint256 amount) external payable canFarmSnow {
// ... payment + mint ...
s_earnTimer = block.timestamp; // ← any buyer's timestamp blocks all earners
emit SnowBought(msg.sender, amount);
}

The semantic intent (per README: "earned for free once a week") implies a per-user rate limit. The implementation is a global rate limit any user can trigger, with two attack flavors:

(a) Earner-griefs-earners: User A calls earnSnow(), sets s_earnTimer = T_A. All other users' earnSnow() calls revert for 1 week. Whoever acts first each week is the only user who can earn.

(b) Buyer-griefs-earners (worse): A whale calls buySnow(any_amount) weekly. Each call resets s_earnTimer. Free-earn is permanently blocked for everyone — and the whale doesn't even need to attack maliciously, normal protocol usage suffices.

Risk

  • Likelihood: High — single permissionless call, no preconditions; any honest user's interaction with earnSnow or buySnow triggers the DoS for everyone else.

  • Impact: Medium — the documented free-earn pathway is functionally destroyed for all users except the first to act each week; no funds are at risk and the paid buySnow pathway remains functional.

  • Risk = Likelihood × Impact = Medium

Impact

The protocol's "earn for free once a week" feature is degraded from per-user to whoever-acts-first-globally. With one whale or bot continuously calling buySnow (a normal usage pattern, not even adversarial), every other user is permanently blocked from earnSnow for the lifetime of the contract. No funds are at risk, but the documented free-acquisition mechanism is destroyed and downstream airdrop eligibility — which depends on accumulated Snow balance — is gated to the same first-mover.

Proof of Concept

Full PoC at .audit/poc/PoC_M-02.t.sol. The key test function:

function test_EarnerBlocksOtherEarners() public {
address userA = makeAddr("userA");
address userB = makeAddr("userB");
​
// ACT 1: userA earns — sets the global s_earnTimer
vm.prank(userA);
snow.earnSnow();
​
// ACT 2: userB attempts to earn immediately — must revert because s_earnTimer
// was just written by userA, and the check reads the SAME global slot
vm.prank(userB);
vm.expectRevert(Snow.S__Timer.selector);
snow.earnSnow();
​
// userB still blocked 6 days later — proves the lock is global, not per-user
vm.warp(block.timestamp + 6 days);
vm.prank(userB);
vm.expectRevert(Snow.S__Timer.selector);
snow.earnSnow();
​
// After full 1-week elapses, userB can earn (but resets timer for everyone else)
vm.warp(block.timestamp + 2 days);
vm.prank(userB);
snow.earnSnow();
assertEq(snow.balanceOf(userB), 1, "userB earned after 1-week global lock");
}

Test passes inside hardened audit container (forge exit 0). The companion test in the file (test_BuyerBlocksAllEarners) proves the second attack flavor: a single buySnow call blocks all earners for a week.

Recommended Mitigation

Convert s_earnTimer from a single global slot to a per-user mapping, and remove the assignment from buySnow entirely (a token purchase has no semantic relation to the earn rate limit):

// Replace state declaration:
mapping(address => uint256) private s_lastEarnedAt;
​
function earnSnow() external canFarmSnow {
if (block.timestamp < (s_lastEarnedAt[msg.sender] + 1 weeks)) {
revert S__Timer();
}
_mint(msg.sender, 1 * PRECISION); // also fix decimals (see H-02)
s_lastEarnedAt[msg.sender] = block.timestamp;
}
​
function buySnow(uint256 amount) external payable canFarmSnow {
// ... payment + mint ...
// s_earnTimer write REMOVED — buying does not affect earn rate
emit SnowBought(msg.sender, amount);
}

Each user now has their own independent 1-week throttle. The first earn call always passes because s_lastEarnedAt[msg.sender] defaults to 0, and block.timestamp + 1 weeks > 0 always.

Updates

Lead Judging Commences

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