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

[H-03] Missing Participation Tracking in claimSnowman Allows Infinite NFT Minting via Merkle Proof Replay

nezar_alhammadi

Root + Impact

Description

  • Normal Behavior: The contract should ensure that each eligible address in the Merkle Tree can claim their Snowman NFT exactly once. Once a "leaf" is claimed, it must be invalidated.

  • Specific Issue: The contract defines a mapping s_claimers (as noted by Slither's unused-state detector), but it is never updated or checked inside the claimSnowman function. There is no mechanism to mark a receiver as "already claimed," allowing a user to replay the same Merkle Proof and signature indefinitely.

// @> The s_claimers mapping is defined but NEVER used in claimSnowman logic
// src/SnowmanAirdrop.sol#42: mapping(address => bool) public s_claimers;
​
function claimSnowman(address receiver, ...) external {
_isValidMerkleProof(receiver, proof, amount); // @> Only checks if valid, not if used.
_isValidSignature(receiver, digest, v, r, s); // @> Same here.
// @> VULNERABILITY: No check like "require(!s_claimers[receiver])"
// @> VULNERABILITY: No state update like "s_claimers[receiver] = true"
i_snowman.mintSnowman(receiver, amount);
}

Risk

Likelihood

  • Reason 1: Any user with a valid Merkle Proof can call the function repeatedly without any restriction.

  • Reason 2: The exploit does not require sophisticated tools; it simply involves sending the same transaction multiple times.

Impact:

  • Impact 1 (Infinite Supply Inflation): An attacker can mint an unlimited number of Snowman NFTs, far exceeding the intended supply.

  • Impact 2 (Protocol Collapse): Since the NFT value is tied to its rarity and staking mechanism, allowing infinite minting renders the entire Snowman collection worthless and drains the rewards.

Proof of Concept

  1. Setup: User_A has a valid Merkle Proof for 1 Snowman NFT.

  2. First Claim: User_A calls claimSnowman and successfully receives their NFT.

  3. The Exploit: User_A calls claimSnowman again using the exact same parameters (proof, amount, signature).

  4. Verification Failure: The contract verifies the proof and signature (which are still valid) and proceeds to mint a second NFT to User_A.

  5. Result: User_A can repeat this process thousands of times until the gas or supply is exhausted.

Setup: User_A has a valid Merkle Proof for 1 Snowman NFT.
​
First Claim: User_A calls claimSnowman and successfully receives their NFT.
​
The Exploit: User_A calls claimSnowman again using the exact same parameters (proof, amount, signature).
​
Verification Failure: The contract verifies the proof and signature (which are still valid) and proceeds to mint a second NFT to User_A.
​
Result: User_A can repeat this process thousands of times until the gas or supply is exhausted.

Recommended Mitigation

function claimSnowman(address receiver, bytes32[] calldata proof, uint8 v, bytes32 r, bytes32 s) external {
+ if (s_claimers[receiver]) revert AlreadyClaimed();
// ... validation logic ...
+ s_claimers[receiver] = true;
i_snowman.mintSnowman(receiver, amount);
}
Updates

Lead Judging Commences

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