A recipient can mint Snowman NFTs more than once — the s_hasClaimedSnowman flag is never checked
Description
The SnowmanAirdrop contract is meant to let each eligible address claim its Snowman NFTs exactly once. To track that, it keeps a mapping mapping(address => bool) private s_hasClaimedSnowman, and at the end of a successful claim it sets s_hasClaimedSnowman[receiver] = true.
The problem is that this flag is written but never read. Nowhere in claimSnowman (or anywhere else in the contract) is there a check like if (s_hasClaimedSnowman[receiver]) revert. So the single-claim rule the mapping is clearly designed to enforce is never actually enforced.
This is made worse by the fact that the claimed amount is taken from the caller's live balance at call time, not from a fixed snapshot:
Because the signature is over (receiver, amount) and the merkle leaf is keccak(keccak(abi.encode(receiver, amount))), the same signature and the same merkle proof keep validating every time the receiver is holding that original amount again. Nothing consumes them.
Risk
Impact: High. A single eligible address can mint Snowman NFTs an unbounded number of times, far past its intended one-batch allocation. That breaks the airdrop's core invariant (one claim per eligible recipient) and inflates the Snowman NFT supply arbitrarily.
Likelihood: Medium. Any eligible recipient can do it with the credentials they already hold; the only friction is re-acquiring the same amount of Snow between claims (buySnow, or earnSnow for small amounts). No special access, timing, or victim interaction is required.
Proof of Concept
Add this to the test suite. It claims once, re-acquires the same Snow, replays the identical arguments, and ends up with double the NFTs.
The second claimSnowman succeeds because s_hasClaimedSnowman[alice] is never checked, the live balance equals the original amount again, and the reused signature/proof both re-validate.
Recommended Mitigation
Enforce the flag at the very top of claimSnowman, and add the matching error:
For defence in depth, also bind the claim to the snapshot amount committed in the merkle leaf (rather than reading the caller's live balance), and add a nonce + deadline to the signed message so a signature can never be replayed.
Lead Judging Commences
[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; } ```
Rewards breakdown
Live
The contest is live. Earn rewards by submitting a finding.
Judging
Submissions are being reviewed by our AI judge. Results will be available in a few minutes.
View all submissionsRewards Distribution
The contest is complete and the rewards are being distributed.