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

s_hasClaimedSnowman is written but never read, allowing unlimited Snowman NFT minting

curiux

Root + Impact

claimSnowman sets s_hasClaimedSnowman[receiver] = true after a successful claim but never reads that mapping as a guard anywhere in the function. The flag is a write-only ledger entry. Any eligible address can claim unlimited Snowman NFTs by simply re-acquiring its SNOW allocation between successive calls — for example, by buying it back on a secondary market — inflating NFT supply without bound.

Description

Normal behaviour: The s_hasClaimedSnowman mapping is intended to enforce one claim per address. After claiming, the flag should prevent a second call from succeeding.

The issue: The guard is set but never checked:

// SnowmanAirdrop.sol:94 — flag is written
s_hasClaimedSnowman[receiver] = true;
​
// There is no corresponding read/revert anywhere in claimSnowman():
// if (s_hasClaimedSnowman[receiver]) revert SA__AlreadyClaimed(); // MISSING

Risk

Likelihood:

  • Any eligible address can exploit this without any special privilege

  • The only cost per extra claim is re-acquiring the SNOW allocation (e.g., buying 1 SNOW on secondary market)

  • The signature is replayable indefinitely — no nonce, no deadline, no expiry

  • The Merkle proof is also replayable once the balance is restored to the exact allocation

Impact:

  • Unlimited Snowman NFT inflation from a single address

  • NFT collection value collapses as supply becomes unbounded

  • Each claim drains SNOW from the claimant's wallet into the airdrop contract, which can be combined with a buy-back loop for as long as SNOW is available on the market

  • Protocol trust and tokenomics are permanently broken without redeployment

Proof of Concept

// test/Audit.t.sol — test_poc_bugA_claimGuardMissingDoubleClaim
// Run: forge test --match-test test_poc_bugA_claimGuardMissingDoubleClaim -vvv
​
// Claim #1 — legitimate
vm.prank(alice);
snow.approve(address(airdrop), type(uint256).max);
bytes32 digest1 = airdrop.getMessageHash(alice); // H(alice, 1)
(uint8 v1, bytes32 r1, bytes32 s1) = vm.sign(alKey, digest1);
vm.prank(alice);
airdrop.claimSnowman(alice, AL_PROOF, v1, r1, s1);
// alice: 0 SNOW, 1 NFT, hasClaimed == true
​
// Re-acquire allocation (simulates secondary-market buy)
deal(address(snow), alice, 1);
​
// Claim #2 — should revert; does NOT
bytes32 digest2 = airdrop.getMessageHash(alice); // H(alice, 1) again
(uint8 v2, bytes32 r2, bytes32 s2) = vm.sign(alKey, digest2);
vm.prank(alice);
airdrop.claimSnowman(alice, AL_PROOF, v2, r2, s2); // succeeds
// alice: 0 SNOW, 2 NFTs, hasClaimed still true (useless)
​
// Loop is unbounded — repeat to mint arbitrarily many NFTs

Recommended Mitigation

Add the missing revert at the top of claimSnowman, and define a corresponding custom error:

+ error SA__AlreadyClaimed();
​
function claimSnowman(
address receiver,
bytes32[] calldata merkleProof,
uint8 v, bytes32 r, bytes32 s
) external nonReentrant {
if (receiver == address(0)) revert SA__ZeroAddress();
+ if (s_hasClaimedSnowman[receiver]) revert SA__AlreadyClaimed();
...
}

Additionally, add a nonce or deadline to the EIP-712 struct so that a valid signature cannot be replayed in future claims even if the guard were bypassed:

struct SnowmanClaim {
address receiver;
uint256 amount;
+ uint256 nonce;
}
Updates

Lead Judging Commences

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

[L-01] Missing Claim Status Check Allows Multiple Claims in SnowmanAirdrop.sol::claimSnowman

# Root + Impact   **Root:** The [`claimSnowman`](https://github.com/CodeHawks-Contests/2025-06-snowman-merkle-airdrop/blob/b63f391444e69240f176a14a577c78cb85e4cf71/src/SnowmanAirdrop.sol#L44) function updates `s_hasClaimedSnowman[receiver] = true` but never checks if the user has already claimed before processing the claim, allowing users to claim multiple times if they acquire more Snow tokens. **Impact:** Users can bypass the intended one-time airdrop limit by claiming, acquiring more Snow tokens, and claiming again, breaking the airdrop distribution model and allowing unlimited NFT minting for eligible users. ## Description * **Normal Behavior:** Airdrop mechanisms should enforce one claim per eligible user to ensure fair distribution and prevent abuse of the reward system. * **Specific Issue:** The function sets the claim status to true after processing but never validates if `s_hasClaimedSnowman[receiver]` is already true at the beginning, allowing users to claim multiple times as long as they have Snow tokens and valid proofs. ## Risk **Likelihood**: Medium * Users need to acquire additional Snow tokens between claims, which requires time and effort * Users must maintain their merkle proof validity across multiple claims * Attack requires understanding of the missing validation check **Impact**: High * **Airdrop Abuse**: Users can claim far more NFTs than intended by the distribution mechanism * **Unfair Distribution**: Some users receive multiple rewards while others may receive none * **Economic Manipulation**: Breaks the intended scarcity and distribution model of the NFT collection ## Proof of Concept Add the following test to TestSnowMan.t.sol  ```Solidity function testMultipleClaimsAllowed() public { // Alice claims her first NFT vm.prank(alice); snow.approve(address(airdrop), 1); bytes32 aliceDigest = airdrop.getMessageHash(alice); (uint8 v, bytes32 r, bytes32 s) = vm.sign(alKey, aliceDigest); vm.prank(alice); airdrop.claimSnowman(alice, AL_PROOF, v, r, s); assert(nft.balanceOf(alice) == 1); assert(airdrop.getClaimStatus(alice) == true); // Alice acquires more Snow tokens (wait for timer and earn again) vm.warp(block.timestamp + 1 weeks); vm.prank(alice); snow.earnSnow(); // Alice can claim AGAIN with new Snow tokens! vm.prank(alice); snow.approve(address(airdrop), 1); bytes32 aliceDigest2 = airdrop.getMessageHash(alice); (uint8 v2, bytes32 r2, bytes32 s2) = vm.sign(alKey, aliceDigest2); vm.prank(alice); airdrop.claimSnowman(alice, AL_PROOF, v2, r2, s2); // Second claim succeeds! assert(nft.balanceOf(alice) == 2); // Alice now has 2 NFTs } ``` ## Recommended Mitigation **Add a claim status check at the beginning of the function** to prevent users from claiming multiple times. ```diff // Add new error + error SA__AlreadyClaimed(); function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s) external nonReentrant { + if (s_hasClaimedSnowman[receiver]) { + revert SA__AlreadyClaimed(); + } + if (receiver == address(0)) { revert SA__ZeroAddress(); } // Rest of function logic... s_hasClaimedSnowman[receiver] = true; } ```

Support

FAQs

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

Give us feedback!